Warum boolsche Ergebnisse gemischt mit Integer?

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.
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

BlackJack hat geschrieben:@siggi: Aus welchem Buch die Aufgabe ist hattest Du ja schon mal gesagt — das hat nur nicht jeder griffbereit. ;-)
Ich sehe schon, ich werde halt alt. Ich leihe das Buch gerne aus, löst sich aber langsam auf ;-)
BlackJack hat geschrieben:SmallBasic kannte ich übrigens noch nicht. Wenn ich BASIC-Programme für den PC aus der Zeit zum laufen bringen möchte, nehme ich immer FreeBASIC (http://freebasic.net/). Das wurde mal als freie Implementierung für QBasic/QuickBASIC angefangen (das ist das BASIC was bei MS-DOS nach GW-BASIC dabei war), wurde aber mittlerweile auch um einige Spracheigenschaften erweitert.
Bis gestern kannte ich SmallBasic (nicht zu verwechseln mit Microsofts quälendem Small Basic) auch noch nicht, hab's genommen, weil ich auf die Schnelle nichts einfacheres für 64bit finden konnte, um kurz was zu überprüfen; seit Jahren kommt mir nämlich kein BASIC mehr auf meinen PC. QBasic und Freebasic habe ich früher auch benutzt, ebenso C64 Basic, Basic und Pascal auf der PDP-11, Turbobasic und Turbopascal, Delphi, Lazarus, Lochstreifen auf einer Adler-Rechenmaschine (die Reihenfolge stimmt so nicht), aber Python gefällt mir am besten.

A propos SmallBASIC: ich hoffe das passt noch hierher: wie setze ich das folgende einfache smallbasic Plotprogramm ebenfalls möglichst einfach in Python um?

Ich habe das natürlich mit Python-Pygame, Python-Tkinter und VPython auch gemacht, aber halt komplizierter, aber die Einfachheit mit SmallBasic verblüfft mich doch. Es geht um einen Funktionsplot mit SIN oder auch TAN, oder was auch immer. Hier das SmallBasic Programm, ist nur eine Zeile:

Code: Alles auswählen

PLOT 0, 2*PI USE SIN(x)
Der Plot liegt richtig im Fenster, sieht gut aus, die Fenstehöhe passt sich automatisch an. Kriegt man das in Python auch so einfach oder vergleichbar einfach hin?
BlackJack hat geschrieben:Da es nur *ein* Ergebnis gibt, hätte man da auch ohne Programm durch vereinfachen des boole'schen Ausdrucks drauf kommen können. :-)
Klar, mir ging's nur ums Prinzip, um auch kompliziertere Knobeleien lösen zu können.

Noch etwas, da hier Python-Kobelexperten zugegen sind: in unserer Schulzeit hatten wir uns mit dem ehrlichen und lügenhaften Bewohner beschäftigt; die einfachste Version kennt ihr bestimmt lautet etwa so: "Wanderer kommt an Wegegabelung, ein Männeken steht dort. Wanderer weiss nur, dass derjenige entweder zur Spezies gehört, die immer die Wahrheit sagt oder zur Spezies, die immer lügt. Wie und wieoft muss er also fragen, um den richtigen Weg zu finden?" Ich weiss schon, dass man das mit einer einzigen Frage lösen kann, aber ein gewiefte Mitschüler hat das damals mit Bleistift, Papier und logischen Verknüpfungen ausgerechnet. Wie müsste ich denn in Python vorgehen, um die Lösung zu finden, also mit "brute force"?

Gruss, siggi
Gruss,

siggi
BlackJack

@siggi: Am meisten wird zum Plotten wohl `matplotlib` verwendet. Das ist ein externes Modul und hat Numpy als Abhängigkeit. Damit kann man wesentlich mehr machen als einen Sinus zu plotten. Also ist das vielleicht ein wenig übertrieben.

Code: Alles auswählen

import numpy as np
from matplotlib import pyplot


def main():
    x_values = np.linspace(0, 2 * np.pi, 100)
    pyplot.plot(x_values, np.sin(x_values))
    pyplot.show()


if __name__ == '__main__':
    main()
Die erste Zeile in der `main()`-Funktion erstellt ein Array mit 100 Werten die von 0 bis 2π gehen — beide Endpunkte. Die `plot()`-Funktion möchte nämlich zwei Werte (zumindest wenn man die X-Achse in diesem Fall richtig beschriftet haben möchte): die X-Werte und die dazugehörigen Y-Werte.
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

@BlackJack: sieht nicht übel aus, aber jetzt muss ich erst mal herausfinden wie ich matplotlib auf mein Ubuntu 12.04/Windows 8 bekomme! Per default ist es jedenfalls nicht da. Vielleicht finde ich hier im Forum was.
Gruss,

siggi
BlackJack

@siggi: Also bei Ubuntu ist das über die Paketverwaltung kein Problem.
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

@BlackJack: danke BlackJack, Probleme gibt's auch mit Ubuntu. Für Python2 kein Problem, hatte ich kurz zuvor auch gefunden, aber für Python3 (das ich hauptsächlich benutze) habe ich es nicht gefunden.

Zu pyplot-python2: sieht ja ganz gut aus, mit Achsen und so. Allerdings tritt z.B. bei TAN das Problem auf, dass matplotlib die Funktion ziemlich unschön und ungenau plottet: wo es gegen unendlich geht, verschwindet die Funktion nicht am oberen bzw. unteren Bildrand und die senkrechten Linien sind rundweg falsch. Wer jetzt die Tangens-Funktion nicht kennt, hat eine falsche Vorstellung von der Funktion!

Mit Python-Tkinter habe ich das so einigermaßen hingekriegt, mit "Trick 17"*

Die Fragen sind also mit matplotlib:
1) wie kriege ich mit matplotlib eine Funktion, die gegen +/- unendlich geht, wenigstens bis zum oberen/unteren Fensterrand
2) wie vermeide ich die hässlichen senkrechten Linien?*

*: mit tkinter kriege ich das mit dem "unendlich aussehen" hin und ich lasse ich die "Asymptoten" einfach in anderer Farbe zeichnen, z.B. Hintergrundfarbe (unsichtbar) oder rot (wenn der Plot z.B. schwarz ist), dann sind's halt Asymptoten. Aber es ist schon eine Fitzelei :(

Edit: smallbasic plottet mit Punkten, da sieht man sofort, was Sache ist! Könnte ich denn mit pyplot in erster Annäherung statt mit Linien mit Punkten plotten? Wäre zwar nicht ganz das Wahre, aber immer noch besser als der jetzige witzige Linienplot!
Gruss,

siggi
BlackJack

@siggi: Ah, ich habe nicht daran gedacht das jemand ernsthaft Python 3 einsetzen könnte. :twisted:

Matplotlib ist halt kein Funktionenplotter sondern Plottet tatsächlich die diskreten Werte die man angibt so wie man sie angibt. Für das was Du möchtest müsste man die Funktion analysieren und auch irgendwie entscheiden bis wohin man den Ausschnitt eingrenzt wenn die Werte gegen ±∞ gehen.

Das ungenaue kommt durch die relativ geringe Anzahl der Werte zustande. Statt 100 könnte man auch 1.000 berechnen. Ich vermute mal SmallBasic wird an der Stelle die Anzahl der berechneten Werte mit der Anzahl der Pixel gleichsetzen. Pixel gibt es bei Matplotlib erst wenn tatsächlich die grafische Darstellung ins Spiel kommt. Intern wird das als Vektorgrafik gehandhabt. Als solche kann man das ja auch speichern und dann immer noch verlustfrei skalieren.

Man könnte ein wenig schummeln und Werte die grösser als ein Schwellenwert sind einfach durch NaN ersetzen:

Code: Alles auswählen

import numpy as np
from matplotlib import pyplot


def main():
    x_values = np.linspace(0, 2 * np.pi, 100)
    y_values = np.tan(x_values)
    y_values[abs(y_values) > 50] = np.nan
    pyplot.plot(x_values, y_values, '.')
    pyplot.show()
Edit: Punkte statt Linien.
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

BlackJack hat geschrieben:@siggi: Ah, ich habe nicht daran gedacht das jemand ernsthaft Python 3 einsetzen könnte. :twisted:
Wieso? Selbst die neuesten Auflagen von "Python for Kids" und "Python für Kids" benutzen Python3. Ich bin zwar erwachsen, will aber mit den Kids mithalten können.
Man könnte ein wenig schummeln und Werte die grösser als ein Schwellenwert sind einfach durch NaN ersetzen:
Deine nan-Schummelei gefällt mir gut! Ich hatte es mit tkinter mit veränderter Plotfarbe gemacht.

Aber, angeregt durch unsere Diskussion bin ich eben zu meinen VPython (python-visual) Anfängen zurückgekehrt, da geht's auch ohne Schummeln:

Code: Alles auswählen

#!/usr/bin/python2

import math
from visual import * # must import visual or vis first
from visual.graph import * # import graphing features

gd = gdisplay(title='tangent', ymax=100, ymin=-100)
# f1 = gcurve(color=color.white) # a graphics curve
f1 = gdots(color=color.white, dot=True, size=1) # a graphics dot curve

for x in arange(0, 2*math.pi, 0.001): #
	f1.plot(pos=(x,tan(x))) # plot 
Mit "gdots" gibt's Punkte wie in deinem Beispiel, mit "gcurve" kriegst du Linien. Ich wollte VPython nicht mehr benutzen, weil es noch nicht für Python3 kompatibel ist (?), aber da ich mit matplotlib dasselbe Problem hätte, bleibe ich lieber bei VPython, es ist für mein simples Gemüt leichter zu handhaben (und kann auch tolle 3-D Sachen, z.B. http://www.visualrelativity.com/vpython/; danke, dass du mich auf letzeres wieder gebracht hast, ich habe mir das, glaube ich, das letzte Mal vor mehr als 10 Jahren angeschaut).
Gruss,

siggi
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

Ich habe gerade in der von mir o. zitierten Website http://www.visualrelativity.com/vpython/ gesehen, dass man VPython auch mit einem DAtenhandschuh (?) steuern kann "VPython with the Wiimote". Könnte man Python-Programme auch mit der Stimme steuern, über das Notebook-Micro z.B.? Vor Jahren hatte ich mir mal ein kleines Pythonprogramm "geklaut" und modifiziert, sodass es meine e-Mails oder Eingaben in englischer Sprache ausgeben konnte. Ginge das auch anders herum? Mit Python, oder entsprechenden Moduln?
Gruss,

siggi
BlackJack

@siggi: Du merkst ja selber das man sich immer die Frage stellen muss „gibt's dass schon für Python 3”, und in einigen Fällen ist die Antwort halt „Nein”. Dann stelle ich mir die Gegenfrage „Was bringt mir Python 3 gegenüber Python 2 an Vorteilen”, da komme ich auf die Antwort „wenig”. Dann ist die nächste naheliegende Frage ob die Nachteile die Vorteile aufwiegen. Und das tun sie, zumindest für mich, überhaupt nicht.

Programmierbücher für Kids werden wahrscheinlich mit Python und der Standardbibliothek oder wenigen externen Modulen auskommen. Ich habe eine Menge Python-Code der eine Menge Module verwendet. Nicht alles davon ist für Python 3 verfügbar. Das heisst einiges kann ich nicht portieren und bei dem was ich portieren kann, habe ich die Arbeit es zu portieren um dann den Vorteil… ja welchen eigentlich?

Solange Python 3 nicht das Standardpython bei den meisten Linux-Distributionen ist, und man alles (für mich wichtige) was man jetzt für Python 2 über die Paketverwaltung auch für Python 3 installieren kann, lohnt es sich für mich nicht auf Python 3 umzusteigen. Selbst dann habe ich beruflich noch mit Python-Versionen bis runter zu 2.4 zu tun. (Ja ich weiss, das ist bitter. :-))

Als „Datenhandschuh” würde ich die Wiimote nicht bezeichnen. Von einem Datenhandschuh würde man deutlich mehr Daten als nur Ausrichtung und Beschleunigung erwarten. Also insbesondere die Stellung der Finger, so dass man den Fingerspitzen und jedem Fingergelenk eine relative Position im Raum zuordnen kann. Und die Sensordaten der Wiimote sollte heute eigentlich jedes Smartphone liefern können. Oder man bastelt sich selbst etwas.

VPython ist mir als Projekt etwas suspekt. Wenn man das in aktuell für Linux haben möchte, schlagen die einem allen ernstes als empfehlenswertes Vorgehen vor die aktuelle Version mit Wine laufen zu lassen. Also auch Python in der Windowsversion zu installieren. WTF‽

Python 3-Unterstützung gab es mal bei VPython 5.x, aktuell bei VPython 6.x wieder nicht.

Sprachausgabe ist bedeutend einfacher als Spracheingabe. Für Windows gibt es wohl Python-Module mit denen man die „Windows Speech Recognition”-API und „Dragon NaturallySpeaking” verwenden kann. Keine Ahnung ob die was taugen. Ausserdem bietet Google eine Web-API an. Aber da würde man Google Daten in den Rachen werfen und die API hat sicher irgendwelche Begrenzungen, weil Audiodaten nicht gerade klein sind.

Für das Ausgangsproblem habe ich noch mal eine Lösung mit hilfe eines externen Moduls geschrieben:

Code: Alles auswählen

#!/usr/bin/env python
from inspect import getargspec
from pyconstraints import Problem


def main():
    problem = Problem()
    for variable in 'abcde':
        problem.add_variable(variable, (True, False))
    constraints = [
        lambda a, b: (a and b) or (not a),
        lambda b, c: (b and not c) or (not b and c),
        lambda d, e: not d and e,
        lambda c, e: (c and e) or (not c and not e),
        lambda a, d, e: (d and a and e) or (not d),
    ]
    for constraint in constraints:
        problem.add_constraint(constraint, getargspec(constraint).args)
    for solution in problem.iter_solutions():
        print solution


if __name__ == '__main__':
    main()
Hier muss man nur noch die Variablen und ihre möglichen Werte und die Bedingungen in Form von Funktionen angeben. Der eigentliche Algorithmus die Lösung(en) zu finden steckt in dem externen Modul.

Das ist in diesem Fall mit Kanonen auf Spatzen geschossen, weil der Suchraum mit 32 möglichen Fällen natürlich klein genug ist um ihn selbst auf einem C64 schnell durchzuprobieren. Aber das ist vielleicht auch dem Umstand geschuldet, dass das eine Problemstellung war, die 1982 in BASIC auf damaligen Rechnern umsetzbar sein musste. Wenn man mehr Variablen und mehr als nur zwei Möglichkeiten pro Variable hat, dann explodiert der Suchraum und man kommt schnell in Grössenordnungen von 10 Milliarden Möglichkeiten die man prüfen müsste wenn man es „brute force” macht. Da haben wir hier mal ein Beispiel gehabt: http://www.python-forum.de/viewtopic.php?f=1&t=27986

Das waren mehrere Formeln der Form 'ABC+BDE=FGH' wo jeder Buchstabe für eine Ziffer steht und die Frage war welcher Buchstabe für welche Ziffer(n) stehen kann. Ein Java-Programm das alle Kombinationen durchprobiert hat, lief auf meinem Rechner ≈1½ Minuten, eine Python-Lösung mit `logilab.constraint` nur 2 Sekunden.
BlackJack

Ich konnte mich nicht beherrschen und habe noch mal die späten 80er/frühen 90er aufleben lassen und es für den C64 in Assembler geschrieben. Zwei der Regeln liessen sich da vereinfachen weil der Prozessor neben der Und- und Oder-Verknüpfung auch das Exklusiv-Oder als Befehl bietet. :-)

Code: Alles auswählen

        !to "test.prg", cbm
        !convtab pet
        
        chrout = $ffd2

        tmp = $02
        i = $9e
        a = $b0
        b = $b1
        c = $b2
        d = $b3
        e = $b4
        vars = a
        
        * = $c000

        ; count i from 31 down to 0
        lda #31
        sta i
mainloop:
        ; unpack bit pattern of i to a-e
        lda i
        ldx #4
-       tay
        and #1
        sta vars,x
        tya
        lsr
        dex
        bpl -

        ; the rules. jump to loop end at end of each rule if rule does not
        ; match.

        ; (a and b) or (not a)
        lda a
        and b
        sta tmp
        lda a
        eor #1
        ora tmp
        beq +
        
        ; (b and not c) or (not b and c) <-> b xor c
        lda b
        eor c
        beq +

        ; not d and e
        lda d
        eor #1
        and e
        beq +
        
        ; (c and e) or (not c and not e) <-> not (c xor e)
        lda c
        eor e
        bne +
        
        ; (d and a and e) or (not d)
        lda d
        and a
        and e
        sta tmp
        lda d
        eor #1
        ora tmp
        beq +

        ldy #0          ; print variables as <space> varname ':' value
-       lda #' '
        jsr chrout
        tya
        clc
        adc #'a'
        jsr chrout
        lda #':'
        jsr chrout
        lda vars,y
        ora #'0'
        jsr chrout
        iny
        cpy #5
        bne -

        lda #13         ; print newline
        jsr chrout

+       dec i
        bpl mainloop
        rts
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

BlackJack hat geschrieben:@siggi: Du merkst ja selber das man sich immer die Frage stellen muss „gibt's dass schon für Python 3”...
Vielen Dank, BlackJack, für deine ausführlichen Gedanken! Wie ich sehe, benutzt du Python beruflich; ich selbst nur ein bisschen als Hobby. Ich werde mir das durch den Kopf gehen lassen.
Für das Ausgangsproblem habe ich noch mal eine Lösung mit hilfe eines externen Moduls geschrieben:

Code: Alles auswählen

#!/usr/bin/env python
from inspect import getargspec
from pyconstraints import Problem
...[/quote]
Donnerwetter! Ich hoffe, ich habe dich nicht allzusehr von deiner eigentlichen Arbeit abgehalten! Übrigens, "pyconstraints" ist auf meiner Python 2.7.3 und Python 3.2.3 Umgebung noch nicht drauf. Macht nichts, mir schlackert sowie schon der Schädel vom bisher Gesehenen! Aber irgendwann werde ich es ausprobieren, versprochen!
Gruss,

siggi
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

BlackJack hat geschrieben:Ich konnte mich nicht beherrschen und habe noch mal die späten 80er/frühen 90er aufleben lassen und es für den C64 in Assembler geschrieben. Zwei der Regeln liessen sich da vereinfachen weil der Prozessor neben der Und- und Oder-Verknüpfung auch das Exklusiv-Oder als Befehl bietet. :-)
...
Toll, erinnert mich an alte Zeiten! Habe auch ein bisschen ge"assemblert" damals, aber hauptsächlich nur vorgegebene Programme aus der "C 64" Zeitschrift, und ein paar Hilfsroutinen für CBM Basic an passenden Speicherstellen abgelegt. Sehr gut gefallen hat mir ein Assembler ganz in BASIC geschrieben; nicht weil er so langsam war ;-) sondern weil man das Programm Schritt für Schritt aufbauen konnte und eine Menge dabei lernte - was ich leider inzwischen wieder vergessen habe :(

Hast du das Programm auf deinem alten C64 laufen lassen (unserer wurde wegen Alterswehwechen kürzlich entsorgt), oder hast du einen Emulator benutzt? Ich fand Vice http://www.viceteam.org/ sehr gut. Schwuppdiwupp, wie schnell da alte Band- oder Diskettenprogramme geladen werden konnten!
Ach ja, der C64, mein Herz wird schwer, wenn ich daran denke :( ich vermisse vor allem den herrlichen altmodischen Computersound, und selbst etwas mit "Attack, Decay, Sustain, Release" und den Hüllkurven zu kreieren. Wenn ich ein C-Profi wäre, würde ich mir den Soundteil aus Vice herausschneiden, um sowas auch mal in Python benutzen zu können.
Gruss,

siggi
BlackJack

@siggi: Ein Assembler in BASIC klingt interessant, aber auch irgendwie unpraktisch. Ich hatte erst die Assembler aus der 64'er verwendet — in chronologischer Reihenfolge: Hypra-Ass, Giga-Ass, Vis-Ass, und AssBlaster (der Name wäre sicher nirgends durch eine Marketingabteilung gekommen ;-)). Nach den 64'er „Produkten” den den fast alle „Scener” verwendet haben: Turbo Assembler.

*Das* hatte ich jetzt nicht auf einem C64 laufen lassen, aber den habe ich hier noch einsatzbereit. Ab und zu verschwende ich Zeit damit irgendwelche Knobelaufgaben die mir auf dem PC zu einfach sind, mit den Einschränkungen von Rechenleistung und Speicher vom C64 spannender zu machen. Das durchtesten der 32 Möglichkeiten bei dem Fernseh-Problem war jetzt aber selbst für den C64 in BASIC so furchtbar einfach. ;-)

Das BASIC- und das Assembler-Programm habe ich in der Tat mit VICE getestet. Die aktuelle Webseite ist übrigens http://vice-emu.sourceforge.net/ und nicht mehr die von Dir angegebene. Da ist leider noch alter Inhalt. Aktuell ist VICE 2.4.

Für die SID-Emulation muss man kein C-Profi sein, sondern C++ können. Man muss die reSID-Emulation auch nicht aus VICE extrahieren — die gibt es als eigenständiges Projekt. Und wird auch in anderen Programmen verwendet, wie zum Beispiel ``sidplay2``, dessen `libsidplay2` wiederrum in einigen Plugins für Mediaplayer verwendet wird. Und in ``goattracker``, einem cross-plattform Tracker um SID-Musik auf dem PC zu komponieren, die man dann auch auf dem echten C64 laufen lassen kann. Beide Programme sollten sich unter Ubuntu über die Paketverwaltung installieren lassen.

Wenn man die guten alten SID-Klassiker nur anhören möchte, ist JSidPlay2 (Java-Programm) und die „High Voltage SID Collection” mit über 40.000 SID-Tunes zu empfehlen.

Um die `reSID`-Emulation in Python zu verwenden, müsste man sich ein Python-Modul zum Beispiel mit Cython schreiben.

Softwaresynthesizer mit ADSR & Co gibt es aber auch für den PC einige. Ob da etwas mit Python-Anbindung dabei ist, weiss ich allerdings nicht. Die Wikiseite PythonInMusic ist ziemlich umfangreich und es scheint beispielsweise auch etwas für CSound zu geben.
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

siggi hat geschrieben:@BlackJack: danke BlackJack, Probleme gibt's auch mit Ubuntu. Für Python2 kein Problem, hatte ich kurz zuvor auch gefunden, aber für Python3 (das ich hauptsächlich benutze) habe ich es nicht gefunden...
Es ging um matplotlib: Ist in den Paketquellen erst ab Ubuntu 13.04, aber dank Google gibt es das jetzt auch auf meinem Ubuntu 12.04 für Python3:

https://plus.google.com/115875830338788 ... 6wiYDLptg5

Edit: Ist ja ein gewaltiges Paket! Gibt es da eine gute Einführung dazu (am liebsten auf Englisch) für "Klein Doofy mit Plüschohren" wie mich?
Gruss,

siggi
EyDu
User
Beiträge: 4881
Registriert: Donnerstag 20. Juli 2006, 23:06
Wohnort: Berlin

Schau dich einfach in der Gallerie der matplotlib-Seite um und orientiere dich an dem Code. Und bei der Gelegenheit riskierst du noch einen Blick auf NumPy, sonst kommst du nicht weit ;-)
Das Leben ist wie ein Tennisball.
Benutzeravatar
cofi
Python-Forum Veteran
Beiträge: 4432
Registriert: Sonntag 30. März 2008, 04:16
Wohnort: RGFybXN0YWR0

EyDu hat geschrieben:Schau dich einfach in der Gallerie der matplotlib-Seite um ...
Um das zu vertiefen: Der uebliche Arbeitsablauf mit matplotlib ist wohl
1. Gehe zur Gallerie
2. "Na was sieht denn dem am aehnlichsten was ich machen will?"
3. Code kopieren und anpassen

;)
EyDu
User
Beiträge: 4881
Registriert: Donnerstag 20. Juli 2006, 23:06
Wohnort: Berlin

Das machen aber nur Anfänger. Fortgeschritten matplotlib-Benutzer kopieren aus ihren bereits vorhandenen Projekten.

Profis hingegen haben bereits ein eigenes matplotlib-Modul rumliegen. Die Funktionssignaturen sehen dabei fast genau so aus wie die von matplotlib, nur viel weniger allgemein und mit zufälligen Parametern für die Koordinaten: mal ein mehrdimensionales Array, mal Listen für die einzelnen Achsen oder Listen von Tupeln.

Diese beiden Stufen habe ich zum Glück schon überwunden und erstelle Diagramme nun nur noch mit LaTeX, TikZ und pgfplot. Über die nächste Stufe bin ich mir noch nicht ganz sicher. Wahrscheinlich müssen Python und matplotlib noch irgendwie über das makefile in die LaTeX-Projekte integriert werden. Hat da schon jemand Erfahrung? :lol:
Das Leben ist wie ein Tennisball.
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

@BlackJack:
BlackJack hat geschrieben:...Man könnte ein wenig schummeln und Werte die grösser als ein Schwellenwert sind einfach durch NaN ersetzen...
matplotlib und deine "Schummelei" sind einfach toll. Ich habe jetzt dein Beispiel für mich mit Linien so vereinfacht:

Code: Alles auswählen

# pylab_tan.py

'''
pylab_example: how to handle
infinite y values, according
to BlackJack
'''

import pylab as pl

pl.title('y = tan(x)', color='blue', fontsize=16, fontweight='bold')

x = pl.arange(-pl.pi, pl.pi, 0.01) 
y = pl.tan(x)
y[abs(y) > 10] = pl.nan
pl.plot(x, y)
pl.ylim(-10, 10)
pl.grid(True)

pl.show()
matplotlib wird bis auf weiteres mein liebster Funktionsplot Python2 und Python3 bleiben :)

Gibt's pylab auch für windows (Windows 8, 64bit)?
Gruss,

siggi
siggi
User
Beiträge: 79
Registriert: Montag 29. Januar 2007, 14:22

siggi hat geschrieben:...Gibt's pylab auch für windows (Windows 8, 64bit)?
Ja: http://www.python-forum.de/viewtopic.ph ... 54#p249254
Gruss,

siggi
BlackJack

@siggi: Weil ich gerade wegen eines anderen Themas hier im Forum damit herumspiele: Mit Sagemath kann man auch plotten. Im Hintergrund wird matplotlib verwendet, aber die Sage-`plot()`-Funktion hat auch ein Argument zum erkennen und anzeigen von Polstellen.

Code: Alles auswählen

var('x y')
plot(tan(x), (y, 0, 2*pi), legend_label='tangens', detect_poles='show', ymin=-100, ymax=100, dpi=75)
Was Sage daraus macht:
Bild
Antworten