Das deutsche Python-Forum

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

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.

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

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).

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?

@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.

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

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!

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.

@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 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?

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

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

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?

@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)?

siggi hat geschrieben:...Gibt's pylab auch für windows (Windows 8, 64bit)?

Ja: http://www.python-forum.de/viewtopic.ph ... 54#p249254

@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

Das deutsche Python-Forum

Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?

Re: Warum boolsche Ergebnisse gemischt mit Integer?