File manager - Edit - /home/veronikagstoette/public_html/turtledemo.zip
Back
PK �m#]ʛ�y y tree.pynu ȯ�� #! /usr/bin/python3.12 """ turtle-example-suite: tdemo_tree.py Displays a 'breadth-first-tree' - in contrast to the classical Logo tree drawing programs, which use a depth-first-algorithm. Uses: (1) a tree-generator, where the drawing is quasi the side-effect, whereas the generator always yields None. (2) Turtle-cloning: At each branching point the current pen is cloned. So in the end there are 1024 turtles. """ from turtle import Turtle, mainloop from time import perf_counter as clock def tree(plist, l, a, f): """ plist is list of pens l is length of branch a is half of the angle between 2 branches f is factor by which branch is shortened from level to level.""" if l > 3: lst = [] for p in plist: p.forward(l) q = p.clone() p.left(a) q.right(a) lst.append(p) lst.append(q) for x in tree(lst, l*f, a, f): yield None def maketree(): p = Turtle() p.setundobuffer(None) p.hideturtle() p.speed(0) p.getscreen().tracer(30,0) p.left(90) p.penup() p.forward(-210) p.pendown() t = tree([p], 200, 65, 0.6375) for x in t: pass def main(): a=clock() maketree() b=clock() return "done: %.2f sec." % (b-a) if __name__ == "__main__": msg = main() print(msg) mainloop() PK �m#]JȤ� � turtle.cfgnu �[��� width = 800 height = 600 canvwidth = 1200 canvheight = 900 shape = arrow mode = standard resizemode = auto fillcolor = "" title = Python turtle graphics demo. PK �m#]M�k minimal_hanoi.pynu ȯ�� #! /usr/bin/python3.12 """ turtle-example-suite: tdemo_minimal_hanoi.py A minimal 'Towers of Hanoi' animation: A tower of 6 discs is transferred from the left to the right peg. An imho quite elegant and concise implementation using a tower class, which is derived from the built-in type list. Discs are turtles with shape "square", but stretched to rectangles by shapesize() --------------------------------------- To exit press STOP button --------------------------------------- """ from turtle import * class Disc(Turtle): def __init__(self, n): Turtle.__init__(self, shape="square", visible=False) self.pu() self.shapesize(1.5, n*1.5, 2) # square-->rectangle self.fillcolor(n/6., 0, 1-n/6.) self.st() class Tower(list): "Hanoi tower, a subclass of built-in type list" def __init__(self, x): "create an empty tower. x is x-position of peg" self.x = x def push(self, d): d.setx(self.x) d.sety(-150+34*len(self)) self.append(d) def pop(self): d = list.pop(self) d.sety(150) return d def hanoi(n, from_, with_, to_): if n > 0: hanoi(n-1, from_, to_, with_) to_.push(from_.pop()) hanoi(n-1, with_, from_, to_) def play(): onkey(None,"space") clear() try: hanoi(6, t1, t2, t3) write("press STOP button to exit", align="center", font=("Courier", 16, "bold")) except Terminator: pass # turtledemo user pressed STOP def main(): global t1, t2, t3 ht(); penup(); goto(0, -225) # writer turtle t1 = Tower(-250) t2 = Tower(0) t3 = Tower(250) # make tower of 6 discs for i in range(6,0,-1): t1.push(Disc(i)) # prepare spartanic user interface ;-) write("press spacebar to start game", align="center", font=("Courier", 16, "bold")) onkey(play, "space") listen() return "EVENTLOOP" if __name__=="__main__": msg = main() print(msg) mainloop() PK �m#]���� � forest.pynu ȯ�� #! /usr/bin/python3.12 """ turtlegraphics-example-suite: tdemo_forest.py Displays a 'forest' of 3 breadth-first-trees similar to the one in tree. For further remarks see tree.py This example is a 'breadth-first'-rewrite of a Logo program written by Erich Neuwirth. See http://homepage.univie.ac.at/erich.neuwirth/ """ from turtle import Turtle, colormode, tracer, mainloop from random import randrange from time import perf_counter as clock def symRandom(n): return randrange(-n,n+1) def randomize( branchlist, angledist, sizedist ): return [ (angle+symRandom(angledist), sizefactor*1.01**symRandom(sizedist)) for angle, sizefactor in branchlist ] def randomfd( t, distance, parts, angledist ): for i in range(parts): t.left(symRandom(angledist)) t.forward( (1.0 * distance)/parts ) def tree(tlist, size, level, widthfactor, branchlists, angledist=10, sizedist=5): # benutzt Liste von turtles und Liste von Zweiglisten, # fuer jede turtle eine! if level > 0: lst = [] brs = [] for t, branchlist in list(zip(tlist,branchlists)): t.pensize( size * widthfactor ) t.pencolor( 255 - (180 - 11 * level + symRandom(15)), 180 - 11 * level + symRandom(15), 0 ) t.pendown() randomfd(t, size, level, angledist ) yield 1 for angle, sizefactor in branchlist: t.left(angle) lst.append(t.clone()) brs.append(randomize(branchlist, angledist, sizedist)) t.right(angle) for x in tree(lst, size*sizefactor, level-1, widthfactor, brs, angledist, sizedist): yield None def start(t,x,y): colormode(255) t.reset() t.speed(0) t.hideturtle() t.left(90) t.penup() t.setpos(x,y) t.pendown() def doit1(level, pen): pen.hideturtle() start(pen, 20, -208) t = tree( [pen], 80, level, 0.1, [[ (45,0.69), (0,0.65), (-45,0.71) ]] ) return t def doit2(level, pen): pen.hideturtle() start(pen, -135, -130) t = tree( [pen], 120, level, 0.1, [[ (45,0.69), (-45,0.71) ]] ) return t def doit3(level, pen): pen.hideturtle() start(pen, 190, -90) t = tree( [pen], 100, level, 0.1, [[ (45,0.7), (0,0.72), (-45,0.65) ]] ) return t # Hier 3 Baumgeneratoren: def main(): p = Turtle() p.ht() tracer(75,0) u = doit1(6, Turtle(undobuffersize=1)) s = doit2(7, Turtle(undobuffersize=1)) t = doit3(5, Turtle(undobuffersize=1)) a = clock() while True: done = 0 for b in u,s,t: try: b.__next__() except: done += 1 if done == 3: break tracer(1,10) b = clock() return "runtime: %.2f sec." % (b-a) if __name__ == '__main__': main() mainloop() PK �m#]��"� � fractalcurves.pynu ȯ�� #! /usr/bin/python3.12 """ turtle-example-suite: tdemo_fractalCurves.py This program draws two fractal-curve-designs: (1) A hilbert curve (in a box) (2) A combination of Koch-curves. The CurvesTurtle class and the fractal-curve- methods are taken from the PythonCard example scripts for turtle-graphics. """ from turtle import * from time import sleep, perf_counter as clock class CurvesTurtle(Pen): # example derived from # Turtle Geometry: The Computer as a Medium for Exploring Mathematics # by Harold Abelson and Andrea diSessa # p. 96-98 def hilbert(self, size, level, parity): if level == 0: return # rotate and draw first subcurve with opposite parity to big curve self.left(parity * 90) self.hilbert(size, level - 1, -parity) # interface to and draw second subcurve with same parity as big curve self.forward(size) self.right(parity * 90) self.hilbert(size, level - 1, parity) # third subcurve self.forward(size) self.hilbert(size, level - 1, parity) # fourth subcurve self.right(parity * 90) self.forward(size) self.hilbert(size, level - 1, -parity) # a final turn is needed to make the turtle # end up facing outward from the large square self.left(parity * 90) # Visual Modeling with Logo: A Structural Approach to Seeing # by James Clayson # Koch curve, after Helge von Koch who introduced this geometric figure in 1904 # p. 146 def fractalgon(self, n, rad, lev, dir): import math # if dir = 1 turn outward # if dir = -1 turn inward edge = 2 * rad * math.sin(math.pi / n) self.pu() self.fd(rad) self.pd() self.rt(180 - (90 * (n - 2) / n)) for i in range(n): self.fractal(edge, lev, dir) self.rt(360 / n) self.lt(180 - (90 * (n - 2) / n)) self.pu() self.bk(rad) self.pd() # p. 146 def fractal(self, dist, depth, dir): if depth < 1: self.fd(dist) return self.fractal(dist / 3, depth - 1, dir) self.lt(60 * dir) self.fractal(dist / 3, depth - 1, dir) self.rt(120 * dir) self.fractal(dist / 3, depth - 1, dir) self.lt(60 * dir) self.fractal(dist / 3, depth - 1, dir) def main(): ft = CurvesTurtle() ft.reset() ft.speed(0) ft.ht() ft.getscreen().tracer(1,0) ft.pu() size = 6 ft.setpos(-33*size, -32*size) ft.pd() ta=clock() ft.fillcolor("red") ft.begin_fill() ft.fd(size) ft.hilbert(size, 6, 1) # frame ft.fd(size) for i in range(3): ft.lt(90) ft.fd(size*(64+i%2)) ft.pu() for i in range(2): ft.fd(size) ft.rt(90) ft.pd() for i in range(4): ft.fd(size*(66+i%2)) ft.rt(90) ft.end_fill() tb=clock() res = "Hilbert: %.2fsec. " % (tb-ta) sleep(3) ft.reset() ft.speed(0) ft.ht() ft.getscreen().tracer(1,0) ta=clock() ft.color("black", "blue") ft.begin_fill() ft.fractalgon(3, 250, 4, 1) ft.end_fill() ft.begin_fill() ft.color("red") ft.fractalgon(3, 200, 4, -1) ft.end_fill() tb=clock() res += "Koch: %.2fsec." % (tb-ta) return res if __name__ == '__main__': msg = main() print(msg) mainloop() PK �m#]tn*ܷ � chaos.pynu �[��� # File: tdemo_chaos.py # Author: Gregor Lingl # Date: 2009-06-24 # A demonstration of chaos from turtle import * N = 80 def f(x): return 3.9*x*(1-x) def g(x): return 3.9*(x-x**2) def h(x): return 3.9*x-3.9*x*x def jumpto(x, y): penup(); goto(x,y) def line(x1, y1, x2, y2): jumpto(x1, y1) pendown() goto(x2, y2) def coosys(): line(-1, 0, N+1, 0) line(0, -0.1, 0, 1.1) def plot(fun, start, color): pencolor(color) x = start jumpto(0, x) pendown() dot(5) for i in range(N): x=fun(x) goto(i+1,x) dot(5) def main(): reset() setworldcoordinates(-1.0,-0.1, N+1, 1.1) speed(0) hideturtle() coosys() plot(f, 0.35, "blue") plot(g, 0.35, "green") plot(h, 0.35, "red") # Now zoom in: for s in range(100): setworldcoordinates(0.5*s,-0.1, N+1, 1.1) return "Done!" if __name__ == "__main__": main() mainloop() PK �m#]Ԛ��q q nim.pynu �[��� """ turtle-example-suite: tdemo_nim.py Play nim against the computer. The player who takes the last stick is the winner. Implements the model-view-controller design pattern. """ import turtle import random import time SCREENWIDTH = 640 SCREENHEIGHT = 480 MINSTICKS = 7 MAXSTICKS = 31 HUNIT = SCREENHEIGHT // 12 WUNIT = SCREENWIDTH // ((MAXSTICKS // 5) * 11 + (MAXSTICKS % 5) * 2) SCOLOR = (63, 63, 31) HCOLOR = (255, 204, 204) COLOR = (204, 204, 255) def randomrow(): return random.randint(MINSTICKS, MAXSTICKS) def computerzug(state): xored = state[0] ^ state[1] ^ state[2] if xored == 0: return randommove(state) for z in range(3): s = state[z] ^ xored if s <= state[z]: move = (z, s) return move def randommove(state): m = max(state) while True: z = random.randint(0,2) if state[z] > (m > 1): break rand = random.randint(m > 1, state[z]-1) return z, rand class NimModel(object): def __init__(self, game): self.game = game def setup(self): if self.game.state not in [Nim.CREATED, Nim.OVER]: return self.sticks = [randomrow(), randomrow(), randomrow()] self.player = 0 self.winner = None self.game.view.setup() self.game.state = Nim.RUNNING def move(self, row, col): maxspalte = self.sticks[row] self.sticks[row] = col self.game.view.notify_move(row, col, maxspalte, self.player) if self.game_over(): self.game.state = Nim.OVER self.winner = self.player self.game.view.notify_over() elif self.player == 0: self.player = 1 row, col = computerzug(self.sticks) self.move(row, col) self.player = 0 def game_over(self): return self.sticks == [0, 0, 0] def notify_move(self, row, col): if self.sticks[row] <= col: return self.move(row, col) class Stick(turtle.Turtle): def __init__(self, row, col, game): turtle.Turtle.__init__(self, visible=False) self.row = row self.col = col self.game = game x, y = self.coords(row, col) self.shape("square") self.shapesize(HUNIT/10.0, WUNIT/20.0) self.speed(0) self.pu() self.goto(x,y) self.color("white") self.showturtle() def coords(self, row, col): packet, remainder = divmod(col, 5) x = (3 + 11 * packet + 2 * remainder) * WUNIT y = (2 + 3 * row) * HUNIT return x - SCREENWIDTH // 2 + WUNIT // 2, SCREENHEIGHT // 2 - y - HUNIT // 2 def makemove(self, x, y): if self.game.state != Nim.RUNNING: return self.game.controller.notify_move(self.row, self.col) class NimView(object): def __init__(self, game): self.game = game self.screen = game.screen self.model = game.model self.screen.colormode(255) self.screen.tracer(False) self.screen.bgcolor((240, 240, 255)) self.writer = turtle.Turtle(visible=False) self.writer.pu() self.writer.speed(0) self.sticks = {} for row in range(3): for col in range(MAXSTICKS): self.sticks[(row, col)] = Stick(row, col, game) self.display("... a moment please ...") self.screen.tracer(True) def display(self, msg1, msg2=None): self.screen.tracer(False) self.writer.clear() if msg2 is not None: self.writer.goto(0, - SCREENHEIGHT // 2 + 48) self.writer.pencolor("red") self.writer.write(msg2, align="center", font=("Courier",18,"bold")) self.writer.goto(0, - SCREENHEIGHT // 2 + 20) self.writer.pencolor("black") self.writer.write(msg1, align="center", font=("Courier",14,"bold")) self.screen.tracer(True) def setup(self): self.screen.tracer(False) for row in range(3): for col in range(self.model.sticks[row]): self.sticks[(row, col)].color(SCOLOR) for row in range(3): for col in range(self.model.sticks[row], MAXSTICKS): self.sticks[(row, col)].color("white") self.display("Your turn! Click leftmost stick to remove.") self.screen.tracer(True) def notify_move(self, row, col, maxspalte, player): if player == 0: farbe = HCOLOR for s in range(col, maxspalte): self.sticks[(row, s)].color(farbe) else: self.display(" ... thinking ... ") time.sleep(0.5) self.display(" ... thinking ... aaah ...") farbe = COLOR for s in range(maxspalte-1, col-1, -1): time.sleep(0.2) self.sticks[(row, s)].color(farbe) self.display("Your turn! Click leftmost stick to remove.") def notify_over(self): if self.game.model.winner == 0: msg2 = "Congrats. You're the winner!!!" else: msg2 = "Sorry, the computer is the winner." self.display("To play again press space bar. To leave press ESC.", msg2) def clear(self): if self.game.state == Nim.OVER: self.screen.clear() class NimController(object): def __init__(self, game): self.game = game self.sticks = game.view.sticks self.BUSY = False for stick in self.sticks.values(): stick.onclick(stick.makemove) self.game.screen.onkey(self.game.model.setup, "space") self.game.screen.onkey(self.game.view.clear, "Escape") self.game.view.display("Press space bar to start game") self.game.screen.listen() def notify_move(self, row, col): if self.BUSY: return self.BUSY = True self.game.model.notify_move(row, col) self.BUSY = False class Nim(object): CREATED = 0 RUNNING = 1 OVER = 2 def __init__(self, screen): self.state = Nim.CREATED self.screen = screen self.model = NimModel(self) self.view = NimView(self) self.controller = NimController(self) def main(): mainscreen = turtle.Screen() mainscreen.mode("standard") mainscreen.setup(SCREENWIDTH, SCREENHEIGHT) nim = Nim(mainscreen) return "EVENTLOOP" if __name__ == "__main__": main() turtle.mainloop() PK �m#]2�f�_ _ two_canvases.pynu �[��� """turtledemo.two_canvases Use TurtleScreen and RawTurtle to draw on two distinct canvases in a separate window. The new window must be separately closed in addition to pressing the STOP button. """ from turtle import TurtleScreen, RawTurtle, TK def main(): root = TK.Tk() cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff") cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee") cv1.pack() cv2.pack() s1 = TurtleScreen(cv1) s1.bgcolor(0.85, 0.85, 1) s2 = TurtleScreen(cv2) s2.bgcolor(1, 0.85, 0.85) p = RawTurtle(s1) q = RawTurtle(s2) p.color("red", (1, 0.85, 0.85)) p.width(3) q.color("blue", (0.85, 0.85, 1)) q.width(3) for t in p,q: t.shape("turtle") t.lt(36) q.lt(180) for t in p, q: t.begin_fill() for i in range(5): for t in p, q: t.fd(50) t.lt(72) for t in p,q: t.end_fill() t.lt(54) t.pu() t.bk(50) return "EVENTLOOP" if __name__ == '__main__': main() TK.mainloop() # keep window open until user closes it PK �m#]�6�* * peace.pynu ȯ�� #! /usr/bin/python3.12 """ turtle-example-suite: tdemo_peace.py A simple drawing suitable as a beginner's programming example. Aside from the peacecolors assignment and the for loop, it only uses turtle commands. """ from turtle import * def main(): peacecolors = ("red3", "orange", "yellow", "seagreen4", "orchid4", "royalblue1", "dodgerblue4") reset() Screen() up() goto(-320,-195) width(70) for pcolor in peacecolors: color(pcolor) down() forward(640) up() backward(640) left(90) forward(66) right(90) width(25) color("white") goto(0,-170) down() circle(170) left(90) forward(340) up() left(180) forward(170) right(45) down() forward(170) up() backward(170) left(90) down() forward(170) up() goto(0,300) # vanish if hideturtle() is not available ;-) return "Done!" if __name__ == "__main__": main() mainloop() PK �m#]��P� � clock.pynu ȯ�� #! /usr/bin/python3.12 """ turtle-example-suite: turtledemo/clock.py Enhanced clock-program, showing date and time ------------------------------------ Press STOP to exit the program! ------------------------------------ """ from turtle import * from datetime import datetime dtfont = "TkFixedFont", 14, "bold" current_day = None def jump(distanz, winkel=0): penup() right(winkel) forward(distanz) left(winkel) pendown() def hand(laenge, spitze): fd(laenge*1.15) rt(90) fd(spitze/2.0) lt(120) fd(spitze) lt(120) fd(spitze) lt(120) fd(spitze/2.0) def make_hand_shape(name, laenge, spitze): reset() jump(-laenge*0.15) begin_poly() hand(laenge, spitze) end_poly() hand_form = get_poly() register_shape(name, hand_form) def clockface(radius): reset() pensize(7) for i in range(60): jump(radius) if i % 5 == 0: fd(25) jump(-radius-25) else: dot(3) jump(-radius) rt(6) def display_date_time(): global current_day writer.clear() now = datetime.now() current_day = now.day writer.home() writer.forward(distance=65) writer.write(wochentag(now), align="center", font=dtfont) writer.back(distance=150) writer.write(datum(now), align="center", font=dtfont) writer.forward(distance=85) def setup(): global second_hand, minute_hand, hour_hand, writer mode("logo") make_hand_shape("second_hand", 125, 25) make_hand_shape("minute_hand", 115, 25) make_hand_shape("hour_hand", 90, 25) clockface(160) second_hand = Turtle() second_hand.shape("second_hand") second_hand.color("gray20", "gray80") minute_hand = Turtle() minute_hand.shape("minute_hand") minute_hand.color("blue1", "red1") hour_hand = Turtle() hour_hand.shape("hour_hand") hour_hand.color("blue3", "red3") for hand in second_hand, minute_hand, hour_hand: hand.resizemode("user") hand.shapesize(1, 1, 3) hand.speed(0) ht() writer = Turtle() writer.ht() writer.pu() writer.bk(85) display_date_time() def wochentag(t): wochentag = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] return wochentag[t.weekday()] def datum(z): monat = ["Jan.", "Feb.", "Mar.", "Apr.", "May", "June", "July", "Aug.", "Sep.", "Oct.", "Nov.", "Dec."] j = z.year m = monat[z.month - 1] t = z.day return "%s %d %d" % (m, t, j) def tick(): t = datetime.today() sekunde = t.second + t.microsecond*0.000001 minute = t.minute + sekunde/60.0 stunde = t.hour + minute/60.0 try: tracer(False) # Terminator can occur here second_hand.setheading(6*sekunde) # or here minute_hand.setheading(6*minute) hour_hand.setheading(30*stunde) if t.day != current_day: display_date_time() tracer(True) ontimer(tick, 100) except Terminator: pass # turtledemo user pressed STOP def main(): tracer(False) setup() tracer(True) tick() return "EVENTLOOP" if __name__ == "__main__": mode("logo") msg = main() print(msg) mainloop() PK �m#]ޜ1$� � sorting_animate.pynu ȯ�� #! /usr/bin/python3.12 """ sorting_animation.py A minimal sorting algorithm animation: Sorts a shelf of 10 blocks using insertion sort, selection sort and quicksort. Shelves are implemented using builtin lists. Blocks are turtles with shape "square", but stretched to rectangles by shapesize() --------------------------------------- To exit press space button --------------------------------------- """ from turtle import * import random class Block(Turtle): def __init__(self, size): self.size = size Turtle.__init__(self, shape="square", visible=False) self.pu() self.shapesize(size * 1.5, 1.5, 2) # square-->rectangle self.fillcolor("black") self.st() def glow(self): self.fillcolor("red") def unglow(self): self.fillcolor("black") def __repr__(self): return "Block size: {0}".format(self.size) class Shelf(list): def __init__(self, y): "create a shelf. y is y-position of first block" self.y = y self.x = -150 def push(self, d): width, _, _ = d.shapesize() # align blocks by the bottom edge y_offset = width / 2 * 20 d.sety(self.y + y_offset) d.setx(self.x + 34 * len(self)) self.append(d) def _close_gap_from_i(self, i): for b in self[i:]: xpos, _ = b.pos() b.setx(xpos - 34) def _open_gap_from_i(self, i): for b in self[i:]: xpos, _ = b.pos() b.setx(xpos + 34) def pop(self, key): b = list.pop(self, key) b.glow() b.sety(200) self._close_gap_from_i(key) return b def insert(self, key, b): self._open_gap_from_i(key) list.insert(self, key, b) b.setx(self.x + 34 * key) width, _, _ = b.shapesize() # align blocks by the bottom edge y_offset = width / 2 * 20 b.sety(self.y + y_offset) b.unglow() def isort(shelf): length = len(shelf) for i in range(1, length): hole = i while hole > 0 and shelf[i].size < shelf[hole - 1].size: hole = hole - 1 shelf.insert(hole, shelf.pop(i)) return def ssort(shelf): length = len(shelf) for j in range(0, length - 1): imin = j for i in range(j + 1, length): if shelf[i].size < shelf[imin].size: imin = i if imin != j: shelf.insert(j, shelf.pop(imin)) def partition(shelf, left, right, pivot_index): pivot = shelf[pivot_index] shelf.insert(right, shelf.pop(pivot_index)) store_index = left for i in range(left, right): # range is non-inclusive of ending value if shelf[i].size < pivot.size: shelf.insert(store_index, shelf.pop(i)) store_index = store_index + 1 shelf.insert(store_index, shelf.pop(right)) # move pivot to correct position return store_index def qsort(shelf, left, right): if left < right: pivot_index = left pivot_new_index = partition(shelf, left, right, pivot_index) qsort(shelf, left, pivot_new_index - 1) qsort(shelf, pivot_new_index + 1, right) def randomize(): disable_keys() clear() target = list(range(10)) random.shuffle(target) for i, t in enumerate(target): for j in range(i, len(s)): if s[j].size == t + 1: s.insert(i, s.pop(j)) show_text(instructions1) show_text(instructions2, line=1) enable_keys() def show_text(text, line=0): line = 20 * line goto(0,-250 - line) write(text, align="center", font=("Courier", 16, "bold")) def start_ssort(): disable_keys() clear() show_text("Selection Sort") ssort(s) clear() show_text(instructions1) show_text(instructions2, line=1) enable_keys() def start_isort(): disable_keys() clear() show_text("Insertion Sort") isort(s) clear() show_text(instructions1) show_text(instructions2, line=1) enable_keys() def start_qsort(): disable_keys() clear() show_text("Quicksort") qsort(s, 0, len(s) - 1) clear() show_text(instructions1) show_text(instructions2, line=1) enable_keys() def init_shelf(): global s s = Shelf(-200) vals = (4, 2, 8, 9, 1, 5, 10, 3, 7, 6) for i in vals: s.push(Block(i)) def disable_keys(): onkey(None, "s") onkey(None, "i") onkey(None, "q") onkey(None, "r") def enable_keys(): onkey(start_isort, "i") onkey(start_ssort, "s") onkey(start_qsort, "q") onkey(randomize, "r") onkey(bye, "space") def main(): getscreen().clearscreen() ht(); penup() init_shelf() show_text(instructions1) show_text(instructions2, line=1) enable_keys() listen() return "EVENTLOOP" instructions1 = "press i for insertion sort, s for selection sort, q for quicksort" instructions2 = "spacebar to quit, r to randomize" if __name__=="__main__": msg = main() mainloop() PK �m#]��n paint.pynu ȯ�� #! /usr/bin/python3.12 """ turtle-example-suite: tdemo_paint.py A simple event-driven paint program - left mouse button moves turtle - middle mouse button changes color - right mouse button toggles between pen up (no line drawn when the turtle moves) and pen down (line is drawn). If pen up follows at least two pen-down moves, the polygon that includes the starting point is filled. ------------------------------------------- Play around by clicking into the canvas using all three mouse buttons. ------------------------------------------- To exit press STOP button ------------------------------------------- """ from turtle import * def switchupdown(x=0, y=0): if pen()["pendown"]: end_fill() up() else: down() begin_fill() def changecolor(x=0, y=0): global colors colors = colors[1:]+colors[:1] color(colors[0]) def main(): global colors shape("circle") resizemode("user") shapesize(.5) width(3) colors=["red", "green", "blue", "yellow"] color(colors[0]) switchupdown() onscreenclick(goto,1) onscreenclick(changecolor,2) onscreenclick(switchupdown,3) return "EVENTLOOP" if __name__ == "__main__": msg = main() print(msg) mainloop() PK �m#]�|)�<