Rechnen mit python3

Wir werden als nächsten Schritt die Taschenrechnertauglichkeit des python-Interpreters testen. Python-Interpreter aufrufen, falls er noch nicht offen ist, und los geht's.

user@linux:~> python3
Python 3.2 (r32:88445, Feb 21 2011, 04:07:45) 
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 1 + 2 + 3
6
>>> 1 * 2 * 3
6
>>> print (1+1)
2
>>> 1+  1
2
>>> 1 + 1
2
>>> 1  +1
2
>>> 3 * 5
15
>>> 3 * 5 -2
13
>>> 3 * (5 -2)
9
>>>

Das Ding kann also wirklich Rechnen. Wir sahen, dass die 1+1 und 1 + 1 funktionieren - python ist, was Leerzeichen im Ausdruck angeht, tolerant (gerade am Anfang des Ausdrucks darf kein Leerzeichen stehen).
Ich bevorzuge 1 + 1 aus Gründen der Übersichtlichkeit.

Die Rechenregeln werden freilich auch beherrscht. Punktrechnung vor Strichrechnung, und Klammernausdrücke komman vor allen anderen.
Neben den Grundrechnungsarten +, -, * und / gibt es noch % zunm Restklassenrechnen und ** zum Potenzieren. "2**4" ist also "zwei hoch vier"

>>> 2**8
256
>>>

Aber Achtung!

>>> -2**4
-16
>>>

Wie bitte? -2*-2*-2*-2 ist doch 16, und NICHT -16. Das stimmt auch. Aber hier (in python) verhält es sich insofern anders, als dass -1*(2**4) ausgeführt wird. Man braucht also folgende Schreibweise:

>>> (-2)**4
16
>>>

Man kann eine Rechnung (im Interpreter, NICHT im skript-file) auch in mehrere Etappen einteilen. Dazu verhilft uns der Umstand, dass Ergebnisse einer abgesetzten Rechnung in _ (Unterstrich) abgelegt werden. Ein Beispiel sagt mehr als Tausend Worte:

>>> (10+15+1313+44+455121112)/5.
91024498.799999997
>>> 10+15+1313+44+455121112
455122494
>>> _ / 5.
91024498.799999997
>>> 8 * 2
16
>>> _ - 3
13
>>> 

Jetzt sehen wir uns die Eigenart beim Dividieren an.

>>> 2 / 3
0.6666666666666666
>>> 2 // 3
0
>>> 2 // 3.
0.0
>>>

Eine ganze Zahl dividiert durch eine weitere ganze Zahl ergibt eine Gleitpunktzahl (float). Sind beide (Divisor und Divident) floats oder nur einer der beiden, kommt auch ein float heraus.
3 / 3 ergibt 1.0.
Mit zwei Slashes wird die Division so durchgeführt, dass das Ergebnis ge-floored wird, das heißt, die Gleitpunktzahl wird abgerundet und als Komma Null ausgegeben.

Eine Kommazahl wird übrigens mit Punkt und nicht mit Beistrich (wie von der Schule gewohnt) geschrieben!

>>>  2.4 / 1.2
2.0
>>>

Gleitpunktzahlen werden auch Fließkommazahlen genannt. Auf Englisch floating point, woraus sich mit der Zeit der Begriff float ergeben hat.

>>> 2.0 / 3.0
0.66666666666666663
>>> 2. / 3.
0.66666666666666663
>>>

Wir sehen, dass beide Schreibweisen funktionieren. Das bloße Anhängen des Punktes macht aus int ein float, und was ich mich erinnere, war das bei Taschenrechnern in den 1970ern auch schon so.

Die Rechenzeichen werden als Operator bezeichnet.

>>> 14 % 4
2
>>> (21+9)%24 #21 Uhr plus 9 Stunden
6
>>>  6.8 / 2.4
2.8333333333333335
>>> 6.8 // 2.4
2.0
>>>

Potenzieren hatten wir schon weiter oben gezeigt.

>>> 2 ** 3
8
>>> 2 ** 3.
8.0
>>>

Wenn man Potenzieren kann, wie steht es da mit Wurzelziehen? Geht das?

>>> 4 ** 0.5
2.0
>>> 27 ** 1./3.
9.0
>>>

Oups! Ah, da greifen wieder die Vorrangregeln!

>>> (27 ** 1.)/3.
9.0
>>> 27 ** (1./3.)
3.0
>>> (2**0.5)*(2**0.5)
2.0000000000000004
>>> 2**0.5*2**0.5
2.0000000000000004
>>>

Das Rechnen mit Fließkommazahlen am Computer ist mit (Rundungs-)Fehlern des Mikroprozessors (CPU) verbunden, was zu kleinen Ungenauigkeiten führt, die in der Raumfahrt große Wirkung haben kann.
In der Astronomie muss man darauf Rücksicht nehmen. Gerade da braucht man verlässliche Genauigkeit (arbitrary precision), und die erhält man durch Einatz ds decimal-Moduls (Teil der STL).
Für herkömmliche Rechnungen sollte aber die Genauigkeit von float-Rechnungen ausreichend genau sein.

Eine weitere und in python üblichere Art des Wurzelziehens werden wir uns in bälde in einem anderen link erarbeiten (dann, wenn wir das math-Modul kennenlernen).

Bruchrechnung

Das Rechnen mit Brüchen ist sehr einfach gehalten. Wir wollen uns vom fractions-Modul vorerst nur die Klasse Fraction holen. (Falls die Begriffe Modul oder Klasse noch unbekannt für dich sind, dann nimm die codezeilen einmal so hin, und es klärt sich später alles im basis-Bereich auf)

>>> from fractions import Fraction
>>> bruch1 = Fraction( 1,2 )
>>> bruch2 = Fraction( 5,6 )
>>> print( bruch1 )
1/2
>>> print( bruch2 ) 
5/6
>>> print( bruch1 + bruch2 )
4/3
>>> print( bruch1 / bruch2 )
3/5

Man kann da also viel herumrechnen. Subtraktionen, Multiplikationen zweier Brüche kannste auch gleich selber ausprobieren.
Mit der builtin-function divmod() kann man sich ausgeben lassen, wie oft der Divisor in den dividenten hinpasst (erster Wert der Rückgabe), und wieviel Rest bleibt (zweiter Wert der Rückgabe).

>>> erg = bruch1 + 2*bruch2
>>> divmod( erg.numerator, erg.denominator )
(2, 1)
>>> print( erg )
13/6
>>>