Du kannst also besser Russisch lernen, indem du es nicht aus einem Lehrbuch lernst, weil du schon Französisch kannst?aviable hat geschrieben:Ein Witz: ich kann den Hexcode vom 64 besser lesen, als mancher die Tageszeitung.
Hier mal ein paar Beispiele, die zeigen, warum das die falsche Einstellung sein könnte:
Mein Lieblings-Prolog-Programm:
Code: Alles auswählen
append_dl(A - B, B - C, A - C).
Und die zentrale Stelle in meinem in Python geschriebenen Prolog-Interpreter:
Code: Alles auswählen
def _resolve(self, *, db, choice_points, yes, no, prune):
choice_point = self.choice_point(db)
choice_points.append(choice_point)
here = len(choice_points)
@tco
def prune_here():
while here <= len(choice_points):
choice_points.pop().close()
return no()
@tco
def try_next():
for goal in choice_point:
break
else:
return prune() if is_cut(self) else no()
if goal is None:
return yes(try_next)
else:
return goal.ref._resolve(
db=db,
choice_points=choice_points,
yes=yes,
no=try_next,
prune=prune_here,
)
return try_next()
Das Problem, siehst du, ist, dass Python-Code oft auf einem viel höheren Abstraktionsniveau lebt, als Assembler-, C- oder Basic-Code. EInige Abstraktionen sind in die Sprache schon einegebaut, wie zB. Iteratoren, Coroutinen, Dekoratoren (via First Class Functions) und Metaklassen, und man kann diese wiederum verwenden, um eigene Abstraktionen zu bauen. Python kennt keine Tail Calls? Kein Problem:
Code: Alles auswählen
import functools
def trampoline(bouncing, *args, **kwargs):
while bouncing:
bouncing, result, args, kwargs = bouncing(*args, **kwargs)
yield from result
def land(*args, **kwargs):
return None, (), args, kwargs
def throw(cont, *args, _=None, **kwargs):
return cont, [_], args, kwargs
def bounce(cont, *args, **kwargs):
return cont, (), args, kwargs
def tco(function):
return functools.partial(bounce, function)
Manche dieser Abstraktionen führen zu komplett unterschiedlichen Herangehensweisen an ein Problem. Bei deinem Beispielprogramm in Basic muss die For-Schleife wissen, bis zu welcher Zahl sie zählen muss. In Python würde man einen Generator schreiben:
Code: Alles auswählen
from itertools import islice
from somewhere import plot
def benzol(x, y, a, b, c):
while True:
yield x, y
x, y = ... y ..., ... x .... # aus den alten x und y neue x und y berechnen
def main():
for x, y in islice(benzol(1, 1, -100, 1, 100), 20000):
plot(350 + x, 240 + y)
Nebenbei, die Werte zweier Variablen swappen geht in Python so:
Code: Alles auswählen
x, y = y, x
Ansonsten empfehle ich Learn Python The Hard Way.