def turtles_dance(tree):
screen = Screen()
#
# 0. step - Create root turtle
#
tutroot = turtle_factory(tree[0]["nodes"][1]["color"])
tutroot.left(tree[0]["nodes"][1]["theta"])
tutroot.penup()
tutroot.forward(tree[0]["nodes"][1]["radius"])
tutroot.pendown()
#
# 0.5 step - Root turtle is now the base "layer" for layer 1 of turtles
#
base_turtle = [tutroot]
for layer in tree[1:]:
#
# 1. step - clone new turtles
#
cloned_turtle = []
base_num = -1
nodes = layer["nodes"]
for node in nodes:
if "base_id" in node:
base_num += 1
print("Base_num:", base_num)
pass
else:
cloned_turtle.append(
turtle_clonery(base_turtle[base_num], node["color"]))
#
# 2. Step - Make all turtles face the right direction
#
i = 0
radius = []
for node in nodes:
if "base_id" in node:
continue
else:
radius.append(int(node["radius"]))
cloned_turtle[i].left(node["theta"])
i += 1
#
# 3. Step by step run cloned turtles forward untill they hit
# their max radius from the base.
#
clone_count = len(radius)
forward_count = [0 for i in range(clone_count)]
opened = False
while not opened:
opened = True
for i in range(clone_count):
if forward_count[i] <= radius[i]:
forward_count[i] += 1
cloned_turtle[i].forward(1)
opened = False
#
# 4. Cloned turtles are now the base layer for the next
# layer of turtles
#
base_turtle = cloned_turtle
screen.mainloop()
def score():
pad_x, pad_y = paddle.position()
pad2_x, pad2_y = paddle2.position()
x, y = ball.position()
s1 = 0
s2 = 0
if y < pad_y:
s1 + 1
if y < pad2_y:
s2 + 1
if s1 == 9:
screen.write("BLUE WINS!!! AND IS A TRUE GAMER")
if s2 == 9:
screen.write("RED WINS!!! AND IS A TRUE GAMER")
# if you hit the position of the paddle reverse speed
# We assign up and down are the paddle
screen.onkey(up, "q") # binds q key to the function up for blue()
screen.onkey(down, "a") # binds a key to the function down for blue()
screen.onkey(up2, "p") # binds p key to the function up for red()
screen.onkey(down2, "l") # binds l key to the function down for red()
screen.listen()
move()
score()
screen.mainloop() # start drawing
A = list() # Cria uma lista vazia
for c in range(7):
try:
A.append(int(input('Digite um valor: ')))
except:
print('Erro encotrado. Só números inteiros podem ser inseridos.')
cor = list() # Cria uma lista vazia
cor.append(str(input('Digite a cor da borda: '))) # Cria um elemento para a 1ª posição da lista
cor.append(str(input('Digite a cor do prenchimento: '))) # Cria um elemento para a 2ª posição da lista
tela = Screen() # Mostra a janela e seus atributos
tela.bgcolor("lightgreen")
touche = Turtle() # Cria a tartaruga
touche.pensize(3)
touche.penup()
touche.backward(120)
touche.pendown()
try:
touche.color(cor[0], cor[1])
except:
print('Erro encontrado. Você não inseriu uma cor válida.')
for a in A:
histograma(touche, a)
tela.mainloop()
turtle.shapesize(size / CURSOR_SIZE)
turtle.stamp()
if depth < 1:
return
half = size / 2
circumradius = half * 3**0.5 / 3
for _ in range(3):
turtle.forward(circumradius) # to
sierpinski(depth - 1, turtle, half)
turtle.backward(circumradius) # and fro
turtle.left(120)
window = Screen()
window.mode('logo') # make 0 degrees straight up
window.title('Sierpinski')
window.bgcolor('lightblue')
alex = Turtle('triangle')
alex.fillcolor(window.bgcolor())
alex.penup()
sierpinski(3, alex, 1000)
alex.hideturtle()
window.mainloop()
if nosotros.lower() == nosotros_correct.lower():
sheet_writer.print_answer('nosotros', nosotros_correct, 'correct')
else:
sheet_writer.print_answer('nosotros', nosotros_correct, 'incorrect')
all_correct = False
# Conjugate verb for vosotros.
vosotros = screen.textinput("Yo", "Conjugate the verb for vosotros.")
vosotros_correct = verb.iloc[0].vosotros
if vosotros.lower() == vosotros_correct.lower():
sheet_writer.print_answer('vosotros', vosotros_correct, 'correct')
else:
sheet_writer.print_answer('vosotros', vosotros_correct, 'incorrect')
all_correct = False
# Conjugate verb for ellos/ellas/ustedes.
ellos = screen.textinput("Yo",
"Conjugate the verb for ellos/ellas/ustedes.")
ellos_correct = verb.iloc[0].ellos
if ellos.lower() == ellos_correct.lower():
sheet_writer.print_answer('ellos/ellas/ustedes', ellos_correct,
'correct')
else:
sheet_writer.print_answer('ellos/ellas/ustedes', ellos_correct,
'incorrect')
all_correct = False
verbs.updated_verb_info(index, all_correct)
screen.mainloop()
#Lager lamper a = Lampe() b = Lampe() # Lager skilpadder a.lag_skilpadde() b.lag_skilpadde() a.turtle.forward(100) b.turtle.backward(100) #Skru på B def ff_pa_aav(tut, paa_av): def factory_slaa(): def slaa(): tut.slaa_ + 'paa_av'+ () return slaa_ + 'paa_av' s.onkey(ff_pa_aav(a, 'paa'), 'a') s.onkey(ff_pa_aav(a, 'av'), 'z') s.onkey(ff_pa_aav(b, 'paa'), 's') s.onkey(ff_pa_aav(b, 'av'), 'x') s.listen() s.mainloop()
return [3, 4]
elif opc == 2:
return [4, 6]
else:
return [6, 8]
# Programa principal
[filas, columnas] = menu()
pantalla = Screen()
pantalla.setup(columnas * 50, filas * 50)
pantalla.screensize(columnas * 50, filas * 50)
pantalla.setworldcoordinates(-.5, -.5, columnas + .5, filas + .5)
pantalla.delay(0)
tortuga = Turtle()
tortuga.hideturtle()
simbolo = crea_matriz(filas, columnas)
tablero = crea_matriz(filas, columnas)
temporal1 = None
temporal2 = None
inicializa_tablero(tablero)
rellena_simbolos(simbolo)
dibuja_tablero(tablero, simbolo)
pantalla.onclick(clic)
pantalla.mainloop()
self.x = float(x)
self.y = float(y)
def __str__(self):
return str(self.x) + ',' + str(self.y)
def thirdPos(pointA: PointXY, pointB: PointXY):
third = PointXY()
distAC = math.dist((pointA.x, pointA.y), (pointB.x, pointB.y))
theta = math.acos((pointB.x - pointA.x) / distAC) + math.acos(1 / 2)
third.x = distAC * math.cos(theta) + pointA.x
third.y = distAC * math.sin(theta) + pointA.y
return third
if __name__ == '__main__':
screen_ = Screen()
turtle_ = Turtle()
screen_.setup(600, 600)
turtle_.speed(1)
pointA = PointXY(0, 0)
pointB = PointXY(50, -50)
third = thirdPos(pointA, pointB)
turtle_.goto(pointB.x, pointB.y)
turtle_.penup()
turtle_.goto(pointA.x, pointA.y)
turtle_.pendown()
turtle_.goto(third.x, third.y)
screen_.mainloop()
def start():
global TSM
global nodeAmount
TSM = tsm(nodeAmount, moveEnds = False)
TSM.draw()
s.onkey(start, 'Return')
def drawIterate():
global TSM
if TSM is None:
start()
return
TSM.iterate(1000)
TSM.draw()
s.onkey(drawIterate, 'space')
def clickedOn(x, y):
global TSM
if TSM is None:
start()
return
TSM.toggle(x,y)
s.onclick(clickedOn)
s.listen()
s.mainloop()
class GameView(object):
"""This class handles the user facing part of the game. This draws the
game board and components."""
def __init__(
self,
controller: GameController,
board_size: int,
grid_size: int = 3
) -> None:
self.controller = controller
#### Setup the screen.
# Change it to a square 50% larger than the game board size.
self.screen = Screen()
screen_size = int(board_size * 1.5)
self.resize_screen(screen_size, screen_size)
#### Setup the game board.
# Initialize the turtle that will draw the game board.
self.board = GameView.new_turtle()
self.lineweight = board_size / 60
self.board.pensize(self.lineweight)
self.board.speed(0)
#self.board.dot(0)
self.board_size = board_size
self.grid_size = grid_size
self.grid_line_spacing = board_size / grid_size
#### Create our player markers.
self.players = []
marker_scale = board_size / 100 / grid_size
marker_lineweight = 8 * marker_scale
self.create_player_shapes()
self.players.append(GameView.new_turtle('x marker',
marker_scale,
marker_lineweight))
self.players.append(GameView.new_turtle('o marker',
marker_scale,
marker_lineweight))
#### Final initialization
self.draw_board()
self.screen.onclick(self.mouse_click)
self.screen.mainloop()
def create_player_shapes(self, color: str = 'black') -> None:
"""Creates custom turtle shapes for the x and o player markers.
This method sets up custom shapes that can be used with the
turtle.shape() method. Recall that you could make your turtle look
like an actual turtle (instead of the default arrow shape) by calling
turtle.shape('turtle'). After this method has been called, you can
change the sape of your turtle to an x or an o by calling
turtle.shape('x marker') or turtle.shape('o marker').
These shapes are initialized at a size appropriate for display on a
3x3 grid on a 300px game board.
"""
# Build the x out of a backslash and forward slash.
# These numbers are the vertices of the slashes.
backslash = ((-25,-25), (25,25))
forwardslash = ((-25,25), (25,-25))
shape = Shape('compound')
shape.addcomponent(backslash, '', color)
shape.addcomponent(forwardslash, '', color)
self.screen.register_shape('x marker', shape)
# Approximate the o with a 20-sided polygon.
# These numbers are the vertices of the polygon.
circle = (( 00.00,-25.00), ( 07.73,-23.78), ( 14.69,-20.23),
( 20.23,-14.69), ( 23.78,-07.73), ( 25.00, 00.00),
( 23.78, 07.73), ( 20.23, 14.69), ( 14.69, 20.23),
( 07.73, 23.78), ( 00.00, 25.00), (-07.73, 23.78),
(-14.69, 20.23), (-20.23, 14.69), (-23.78, 07.73),
(-25.00, 00.00), (-23.78,-07.73), (-20.23,-14.69),
(-14.69,-20.23), (-07.73,-23.78),)
shape = Shape('compound')
shape.addcomponent(circle, '', color)
self.screen.register_shape('o marker', shape)
def draw_line(self, x: float, y: float, heading: float, length: float) -> None:
"""Draws a line on the game board.
Args:
x, y: The coordinates where the line starts.
heading: The angle of the line.
length: The length of the line.
"""
self.board.setheading(heading)
self.board.penup()
self.board.goto(x, y)
self.board.pendown()
self.board.forward(length)
def draw_board(self) -> None:
"""Draws the game board centered on the point (0,0)."""
# Each horizontal line will have a common starting x coordinate.
# Each vertical line will have a common starting y coordinate.
# These coordinates are equal to each other.
anchor = self.board_size / 2
# The y-coordinates of horizontal lines and the x-coordinates of
# vertical lines begin equal to each other and increment equally
increments = list(
anchor - i * self.grid_line_spacing
for i in range(1, self.grid_size)
)
for i in increments:
self.draw_line(i, anchor, 270, self.board_size)
self.draw_line(anchor, i, 180, self.board_size)
def mark_play(self, player: int, space: List[int]) -> None:
"""Marks a play on the game board.
Args:
player: The player to mark, based on play order, starting at 1.
space: The space to be marked. The bottom-left space is (0,0).
"""
# Offset the space coordinates so that (0,0) becomes the center space
space = [s - self.grid_size // 2 for s in space]
# Calculate the pixel offset between spaces on the game board
space_offset = self.board_size / self.grid_size
# Find the screen coordinates of the center of the selected space on
# the game board.
center = [space_offset * s for s in space]
current_player = self.players[player - 1]
current_player.goto(*center)
current_player.stamp()
def mouse_click(self, x: float, y: float) -> None:
"""Handles mouse click actions."""
# Ignore all clicks outside of the game board area
extent = self.board_size / 2
if not (-extent < x < extent and -extent < y < extent):
return
# Find the space on the board in which the mose was clicked
# The bottom-left square is space (0,0).
space = [round(c / self.grid_line_spacing) + self.grid_size // 2
for c in [x, y]]
# Ask the controller to make a play in this space
player = self.controller.make_play(space)
# If the play was successful, the controller will return the player
# who made the play
if player:
# Mark the play on the board
self.mark_play(player, space)
def resize_screen(self, width: int, height: int) -> None:
"""Resizes the screen."""
self.screen.setup(width, height)
@staticmethod
def new_turtle(
shape: Optional[str] = None,
scale: float = 1.0,
lineweight: float = 1.0
) -> Turtle:
"""Creates a new turtle and hides it.
Args:
shape: A valid shapename. See TurtleScreen documentation.
scale: A factor to scale the size the turtle.
lineweight: The thickness of the lines composing the shape.
Yields:
TurtleGraphicsError: For invalid shape names.
"""
t = Turtle()
t.shape(shape)
t.shapesize(scale, scale, lineweight)
t.penup()
t.hideturtle()
return t
chiq = Turtle()
chiq.color('red')
chiq.pensize(5)
chiq.speed(0)
chiq.hideturtle()
chiq.up()
chiq.goto(300, 300)
chiq.down()
chiq.goto(300, -300)
chiq.goto(-300, -300)
chiq.goto(-300, 300)
chiq.goto(300, 300)
top = Turtle()
top.shape('circle')
top.up()
top.goto(0, 0)
top.color('blue')
step_x = 3
step_y = 2
while True:
x, y = top.position()
if x + step_x >= 300 or x + step_x <= -300:
step_x = -step_x
if y + step_y >= 300 or y + step_y <= -300:
step_y = -step_y
top.goto(x + step_x, y + step_y)
oyna.mainloop()
class MazeTurtle(Turtle):
def __init__(self, grid_size=50, maze=0):
super().__init__()
self.grid_size = grid_size
self.maze_conf = MAZES[maze]
self.screen = Screen()
self.screen.bgcolor('black')
self.screen.register_shape("star", ((0, 5), (-4, -5), (5, 1), (-5, 1),
(4, -5)))
# Draw the maze
t = Turtle()
t.color('white')
t.shape('square')
t.penup()
t.resizemode('user')
t.shapesize(2, 2, 1)
t.speed('fastest')
for y, row in enumerate(self.maze_conf.splitlines()):
for x, chr in enumerate(row):
if chr == 'X':
t.goto(-288 + x * self.grid_size, 288 - y * self.grid_size)
t.stamp()
# Draw the goal
maze_size = len(self.maze_conf.splitlines()) - 3
t.shape("star")
t.color("yellow")
t.goto(-288 + maze_size * self.grid_size,
288 - (maze_size + 1) * self.grid_size)
t.setheading(90)
t.stamp()
self.speed('fastest')
self.color('green')
self.shape('turtle')
self.showturtle()
self.penup()
self.goto(-288 + self.grid_size, 288 - 2 * self.grid_size)
self.resizemode('user')
self.shapesize(2, 2, 1)
self.pendown()
self.speed('slowest')
# Key bindings
self.screen.listen()
self.screen.onkey(self.step_up, "Up")
self.screen.onkey(self.step_right, "Right")
self.screen.onkey(self.step_down, "Down")
self.screen.onkey(self.step_left, "Left")
def step_up(self):
self._turn_and_move(90)
def step_right(self):
self._turn_and_move(0)
def step_left(self):
self._turn_and_move(180)
def step_down(self):
self._turn_and_move(-90)
def _turn_and_move(self, heading):
self.setheading(heading)
self.forward(self.grid_size)
def mainloop(self):
self.screen.mainloop()
def week__3(myChar):
import turtle , random
from turtle import Turtle, Screen
print(''' Django 볼을 획득하라!
노란색 Django볼을 획득하면 Mission clear 됩니다.''')
screen = Screen()
screen.setup(1200, 500)
Django = Turtle()
Django.shape('circle')
Django.color('yellow')
Django.up()
point_x = random.randint(-500,500)
point_y = random.randint(-250,250)
Django.goto(point_x,point_y)
player = Turtle()
player.speed('fastest')
PlayerY = 0
PlayerX = 0
def play():
if player.distance(Django) < 25:
turtle.clear()
turtle.write("Mission Clear",False,"center",font=("Arial",50,"normal"))
myChar.controlPiro(5)
myChar.controlCoding(10)
if player.distance(Django) > 25:
turtle.clear()
turtle.write("Game Over",False,"center",font=("Arial",50,"normal"))
myChar.controlPiro(5)
myChar.controlMoney(-2)
def moveX():
nonlocal PlayerX
screen.onkeypress(None, "Right")
player.clear()
player.penup()
player.goto(PlayerX, PlayerY)
player.pendown()
player.shape('turtle')
player.color('blue')
PlayerX += 10
screen.onkeypress(moveX, "Right")
def moveY():
nonlocal PlayerY
screen.onkeypress(None, "Up")
player.clear()
player.penup()
player.goto(PlayerX, PlayerY)
player.pendown()
player.shape('turtle')
player.color('blue')
PlayerY += 10
screen.onkeypress(moveY, "Up")
def move_X():
nonlocal PlayerX
screen.onkeypress(None, "Left")
player.clear()
player.penup()
player.goto(PlayerX, PlayerY)
player.pendown()
player.shape('turtle')
player.color('blue')
PlayerX -= 10
screen.onkeypress(move_X, "Left")
def move_Y():
nonlocal PlayerY
screen.onkeypress(None, "Down")
player.clear()
player.penup()
player.goto(PlayerX, PlayerY)
player.pendown()
player.shape('turtle')
player.color('blue')
PlayerY -= 10
screen.onkeypress(move_Y, "Down")
screen.listen()
turtle.ontimer(play, 9000)
moveY()
moveX()
move_X()
move_Y()
screen.mainloop()
points.remove(endingPoint)
routes = []
getRouteDistance("Route One", startingPoint, points[0], points[1], points[2], endingPoint)
getRouteDistance("Route Two", startingPoint, points[1], points[2], points[0], endingPoint)
getRouteDistance("Route Three", startingPoint, points[2], points[0], points[1], endingPoint)
getRouteDistance("Route Four", startingPoint, points[0], points[2], points[1], endingPoint)
getRouteDistance("Route Five", startingPoint, points[1], points[0], points[2], endingPoint)
getRouteDistance("Route Six", startingPoint, points[2], points[1], points[0], endingPoint)
routesSorted = sorted(routes,key=lambda l:l[1])
print(routesSorted[0])
#Turtle graphics
scale = 15
window = Screen()
cursor = Turtle()
cursor.penup()
cursor.goto(routesSorted[0][2][0] * scale, routesSorted[0][2][1] * scale)
cursor.pendown()
for i in range(3):
cursor.goto(routesSorted[0][i+3][0] * scale, routesSorted[0][i+3][1] * scale)
cursor.goto(routesSorted[0][6][0] * scale,routesSorted[0][6][1] * scale)
window.mainloop()
Dim['Y']['upper']
]
win.setworldcoordinates(D[0], D[1], D[2], D[3])
G = Grapher(Dim)
'''
f = lambda x : sin(x)
interval = (0,9,0.1)
Region1 = singlaValueFun_numGen(f,interval)
x_t = lambda t : cos(t)
y_t = lambda t: 2*sin(t)
interval = {
'lower' : 0,
'upper' : 2*pi,
'increment' : 0.1
}
Region2 = ParametricEqu_numGen(x_t,y_t,interval)
'''
r_theta = lambda theta: 3 * cos(2 * theta)
interval = {'lower': 0, 'upper': 2 * pi, 'increment': 0.01}
Region3 = PolarEqu_numGen(r_theta, interval)
win.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)
win.delay(5)
G.plot(Region3)
win.mainloop()
TURTLE.end_fill() # Fill the shape
TURTLE.penup()
TURTLE.goto(100, -50)
TURTLE.setheading(0)
TURTLE.left(30)
TURTLE.pendown()
TURTLE.begin_fill() # Begin to fill color in a shape
TURTLE.color("yellow")
TURTLE.circle(40, steps=6) # Draw a hexagon
TURTLE.end_fill() # Fill the shape
TURTLE.penup()
TURTLE.goto(200, -50)
TURTLE.setheading(0)
TURTLE.left(22.5)
TURTLE.pendown()
TURTLE.begin_fill() # Begin to fill color in a shape
TURTLE.color("purple")
TURTLE.circle(40, steps=8) # Draw a circle
TURTLE.end_fill() # Fill the shape
TURTLE.color("green")
TURTLE.penup()
TURTLE.goto(-100, 50)
TURTLE.pendown()
TURTLE.write("Cool Colorful Shapes", font=("Times", 18, "bold"))
TURTLE.hideturtle()
SCREEN.mainloop()
leo = Turtle()
leo.color('green', 'limegreen')
leo.pensize(5)
# Posiciona a caneta lá embaixo
leo.penup()
leo.goto(0, -200)
leo.pendown()
leo.left(45)
talo(leo)
# Pétalas
leo.color('moccasin', 'gold')
leo.shape("turtle")
leo.pensize(3)
leo.speed(8)
# Comando para fazer as outras pétalas
leo.begin_fill()
for c in range(petala):
desenho(leo, comp)
leo.left(360 / petala)
leo.end_fill()
leo.hideturtle()
est.mainloop()
turtle.forward(sqrt(70))
turtle.left(-145)
turtle.forward(sqrt(70))
turtle.penup()
turtle.goto(WIDTH*(1.26+6),HEIGHT/2)
turtle.right(0.20 * -90-55)
turtle.pendown()
turtle.forward(3.10)
LETTERS = { 'P': letter_P,'A': letter_A,'V':letter_V,'I': letter_I,'K':letter_K,'1': letter_A1}
wn = Screen()
wn.setup(800, 400)
wn.title("Turtle writing my name: {}".format(NAME))
wn.setworldcoordinates(0, 0, BOX_WIDTH * len(NAME), BOX_HEIGHT)
marker = Turtle()
marker.width(4)
for counter, letter in enumerate(NAME):
marker.penup()
marker.goto(counter * BOX_WIDTH + BORDER, BORDER)
marker.setheading(90)
if letter in LETTERS:
marker.pendown()
LETTERS[letter](marker)
marker.hideturtle()
wn.mainloop()
def tictoc():
# Simulate the passage of time for each bubbble
for b in bubbles:
b.sim()
ocean.update()
ocean.ontimer(tictoc, 20)
# Create the initial set of bubbles
for i in range(numBubbles):
blowBubble(random.randint(-50, 50), random.randint(-50, 50))
ocean.onclick(blowBubble)
ocean.ontimer(tictoc, 20)
# What happens if the line below is missing
ocean.mainloop()
numBubbles = 0
if len(sys.argv) > 1:
numBubbles = sys.argv[1]
print("number of bubbles requested", numBubbles)
print("numBubbles type is", type(numBubbles))
# Let's add a few more
numBubbles = numBubbles + 10
print("number of bubbles to make", numBubbles)
# How did that work out?
class Plotter(object):
"""
A plotter object provides a graphical window for plotting data and
mathematical functions.
"""
def __init__(self, width, height, min_x, max_x, min_y, max_y):
""" (Plotter, int, int, int, int, int, int) -> turtle
The constructor initializes the Turtle graphics window.
It accepts parameters that define the window’s physical size and
ranges of x and y axes.
Initializes the plotter with a window that is <width> wide and
<height> high. Its x-axis ranges from <min_x> to <max_x>, and it's
y-axis ranges from <min_y> to <max_y>.
Establishes the global begining and ending x values for the plot and
the x_increament value.
Draws the x-axis and y-axes
"""
# Init
self.pen = Pen() # The plotter object's pen
self.screen = Screen() # The plotter object's sceen
self.pen.speed(0) # Speed up rendering
self.screen.tracer(0, 0) # DONT draw pen while drawing
# Establish global x and y ranges
self.min_x, self.max_x = min_x, max_x
self.min_y, self.max_y = min_y, max_y
self.screen.setup(width=width,
height=height) # Set up window size, in pixels
# set up screen size, in pixels
self.screen.screensize(width, height)
self.screen.setworldcoordinates(min_x, min_y, max_x, max_y)
# x-axis distance that correspond to one pixel in window distance
self.x_increament = (max_x - min_x) / width
self.draw_grid(20)
self.draw_axes()
self.screen.title('Plot')
self.screen.update()
def __del__(self):
""" (Plotter) -> stdout
Called when the client no longer uses the plotter object.
The interpreter calls this method, also known as destructor,
when the object is no longer bound to a reference with in the
executing program.
Among other times, this happens when the program’s execution
terminates.
"""
print('Done Printing')
def draw_axes(self, grid=False):
""" (Plotter, bool) -> turtle
Draws the x and y axes within the plotting window.
An option Boolean parameter <grid> controls the drawing of
accessory horizontal and vertical lines
"""
if grid:
self.draw_grid(20)
self.pen.hideturtle() # Make pen invisible
prev_width = self.pen.width()
self.pen.width(2)
# Draw x axis
self.pen.color('black')
self.draw_arrow(self.min_x, 0, self.max_x, 0)
# Draw y axis
self.draw_arrow(0, self.min_y, 0, self.max_y)
self.pen.width(prev_width)
def draw_grid(self, num):
""" (Plotter, int) -> turtle
Draws horizontal and vertical accessory reference coordinate
lines on the plot. Parameter <num> control the frequency of the
reference lines.
"""
self.pen.up()
# self.pen.setposition(self.min_x, self.min_y)
inc = (self.max_x - self.min_y) / num
self.pen.color('lightblue')
x = self.min_x
while x <= self.max_x:
self.pen.setposition(x, self.min_y)
self.pen.down()
self.pen.setposition(x, self.min_y)
self.pen.up()
x += inc # Next x
inc = (self.max_y - self.min_y) / num
y = self.min_y
while y <= self.max_y:
self.pen.setposition(self.min_x, y)
self.pen.down()
self.pen.setposition(self.max_x, y)
self.pen.up()
y += inc # Next y
def draw_arrow(self, x1, y1, x2, y2):
""" (Plotter, int, int, int, int) -> turtle
Draws a line segment with an attached arrow head.
Expects four numeric parameters representing the (x 1 , y 1 ) tail end
point and (x 2 , y 2 ) head end point of the arrow.
"""
# Draw arrow shaft
self.pen.up()
self.pen.setposition(x1, y1) # Move the pen starting point
self.pen.down() # Draw line bottom to top
self.pen.setposition(x2, y2) # Move the pen starting point
# Draw arrow head
dy = y2 - y1
dx = x2 - x1
angle = atan2(dy, dx) * 180 / pi
self.pen.setheading(angle)
self.pen.stamp()
def plot_function(self, f, color, update=True):
""" (Plotter, func, str, bool) -> turtle
Plots the curve of a given function <f> with a specified color,
established by initialize_plotter.
Plots (x, f(x)), for all x in range min_x <= x < max_x
The color parameter dicatates the curve's color
An optional Boolean parameter determines if the function renders
immediately or requires the client to call the update method after a
series of plots (defaults to True).
"""
# Move pen to starting position
self.pen.up()
self.pen.setposition(self.min_x, f(self.min_x))
self.pen.color(color)
self.pen.down()
# Iterate over the range of x values for min_x <= x < max_x
x = self.min_x
while x < self.max_x:
self.pen.setposition(x, f(x))
x += self.x_increament # Next x
if update:
self.screen.update()
def plot_data(self, data, color, update=True):
""" (Plotter, list, str, bool) -> turtle
Plots the curve (x, y) pairs of values in data_list.
A parameter <color> specifies the curve’s color.
An optional Boolean parameter determines if the function renders
immediately or requires the client to call the update method after a
series of plots (defaults to True).
"""
self.pen.up()
self.pen.setposition(data[0][0], data[0][1])
self.pen.color(color)
self.pen.down()
# Plot the points in th data set
for x, y in data:
self.pen.setposition(x, y)
if update:
self.screen.update()
def update(self):
""" (Plotter) -> turtle
Draws any pending actions to the screen
"""
self.screen.update()
def setcolor(self, color):
""" (Plotter, str) -> turtle
Sets the current drawing color.
"""
self.pen.color(color)
def onclick(self, fun):
""" (Plotter, func) -> turtle
Assigns a callback function that the frame should call when the
user clicks the mouse button when the pointer is over the plotter
window.
The function <fun> must accept two integer parameters that represent
the (x, y) location of the mouse when the click occurred
"""
self.screen.onclick(fun)
def interact(self):
""" (Plotter) -> turtle
Sets the plotter to interactive mode, enabling the user to
provide mouse and keyboard input.
"""
self.screen.mainloop()
class TurtlePlot:
def __init__(self, width, height, title=""):
"""
Initialize a Turtle Plot
Args:
width: Width of the screen
height: Height of the screen
"""
self.width = width
self.height = height
self.title = title
self.screen = Screen()
self.screen.clear()
self.screen.setup(width=width, height=height)
self.screen.setworldcoordinates(0, 0, width, height)
self.screen.tracer(0, 1)
self.screen.onclick(lambda x, y: self.zoom_in(x, y))
self.screen.title(self.title + " (click to zoom in)")
def done(self):
"""
Wait until user clicks or closes screen.
"""
self.screen.mainloop()
def _setworldcoordinates(self, xmin, ymin, xmax, ymax):
try:
self.screen.setworldcoordinates(xmin, ymin, xmax, ymax)
except Exception as e:
pass
def zoom_in(self, x, y):
self._setworldcoordinates(x - 50, y - 50, x + 50, y + 50)
self.screen.onclick(lambda x, y: self.zoom_out())
self.screen.title(self.title + " (click to zoom out)")
def zoom_out(self):
self._setworldcoordinates(0, 0, self.width, self.height)
self.screen.onclick(lambda x, y: self.zoom_in(x, y))
self.screen.title(self.title + " (click to zoom in)")
def draw(self, plot_record: PlotRecord, x_bounds, y_bounds):
"""
Draw a plot on the turtle screen.
Args:
plot_record: The plot record to display.
x_bounds: The plots x bounds
y_bounds: The plots y bounds
"""
outline_turtle = Turtle()
outline_turtle.hideturtle()
xy_turtles = [Turtle() for _ in plot_record.xys]
for i, trtl in enumerate(xy_turtles):
trtl.penup()
trtl.pensize(2)
trtl.pencolor(plot_record.xys[i].color)
trtl.hideturtle()
turtle_xmin, turtle_xmax = x_bounds
turtle_ymin, turtle_ymax = y_bounds
turtle_dx = turtle_xmax - turtle_xmin
turtle_dy = turtle_ymax - turtle_ymin
# leave 20% space on left and bottom
# for labeling
turtle_margin_left = 0.2
turtle_margin_right = 0.2
turtle_margin_bottom = 0.3
turtle_margin_top = 0.3
turtle_x_chart_min = turtle_xmin + (turtle_dx * turtle_margin_left)
turtle_y_chart_min = turtle_ymin + (turtle_dy * turtle_margin_bottom)
turtle_x_chart_max = turtle_xmax - (turtle_dx * turtle_margin_right)
turtle_y_chart_max = turtle_ymax - (turtle_dy * turtle_margin_top)
turtle_dx_chart = turtle_x_chart_max - turtle_x_chart_min
turtle_dy_chart = turtle_y_chart_max - turtle_y_chart_min
fontsize = 8
outline_turtle.penup()
outline_turtle.setposition(
turtle_xmin, (turtle_y_chart_min + turtle_y_chart_max) * 0.5)
outline_turtle.write(plot_record.ylabel)
outline_turtle.setposition(turtle_x_chart_min, turtle_y_chart_max)
outline_turtle.pendown()
outline_turtle.setposition(turtle_x_chart_min, turtle_y_chart_min)
outline_turtle.setposition(turtle_x_chart_max, turtle_y_chart_min)
outline_turtle.penup()
all_xs = [x for xy in plot_record.xys for x in xy.x]
all_ys = [y for xy in plot_record.xys for y in xy.y]
series_xmin = min(all_xs)
series_xmax = max(all_xs)
series_ymin = min(all_ys)
series_ymax = max(all_ys)
series_dx = (series_xmax - series_xmin) or 1
series_dy = (series_ymax - series_ymin) or 1
# scale factor from series to turtle
xscale = turtle_dx_chart / series_dx
yscale = turtle_dy_chart / series_dy
outline_turtle.setposition(turtle_x_chart_min - fontsize,
turtle_y_chart_max - (fontsize * 0.5))
outline_turtle.write("%0.02f" % series_ymax, align='right')
outline_turtle.setposition(
turtle_x_chart_min - fontsize,
turtle_y_chart_min + (turtle_dy_chart * 0.5) - (fontsize * 0.5))
outline_turtle.write("%0.02f" % ((series_ymin + series_ymax) * 0.5),
align='right')
outline_turtle.setposition(turtle_x_chart_min - fontsize,
turtle_y_chart_min - (fontsize * 0.5))
outline_turtle.write("%0.02f" % series_ymin, align='right')
outline_turtle.setposition(turtle_x_chart_max,
turtle_y_chart_min - (fontsize * 2))
outline_turtle.write("%0.02f" % series_xmax, align='center')
outline_turtle.setposition(
turtle_x_chart_min + (turtle_dx_chart * 0.5) - fontsize,
turtle_y_chart_min - (fontsize * 2))
outline_turtle.write("%0.02f" % ((series_xmin + series_xmax) * 0.5),
align='center')
outline_turtle.setposition(turtle_x_chart_min,
turtle_y_chart_min - (fontsize * 2))
outline_turtle.write("%0.02f" % series_xmin, align='center')
for i, xy in enumerate(plot_record.xys):
# position turtle at first xy value
xy_turtles[i].setposition(
turtle_x_chart_min + (xscale * (xy.x[0] - series_xmin)),
turtle_y_chart_min + (yscale * (xy.y[0] - series_ymin)))
xy_turtles[i].pendown()
for j in range(min(len(xy.x), len(xy.y))):
xy_turtles[i].setposition(
turtle_x_chart_min + (xscale * (xy.x[j] - series_xmin)),
turtle_y_chart_min + (yscale * (xy.y[j] - series_ymin)))
xy_turtles[i].penup()
xy_turtles[i].setposition(turtle_x_chart_max + (fontsize * 2),
turtle_y_chart_max - (fontsize * 2 * i))
xy_turtles[i].write(xy.label, align='left')
def run(self):
starttime = time.clock()
anzahl_generationen = 0
screen.onkey(self.stop, "space")
generation = generate(self.state)
self.RUNNING = True
while self.RUNNING:
self.newstate = next(generation)
self.update_display()
self.state = self.newstate
anzahl_generationen +=1
stoptime = time.clock()
t = stoptime - starttime
print(anzahl_generationen, t, anzahl_generationen/t)
def stop(self):
self.RUNNING = False
screen.onkey(self.run, "space")
def main():
game=Game()
return "EVENTLOOP"
if __name__ == "__main__":
msg = main()
print(msg)
screen.mainloop()
class Plotter:
""" A plotter object provides a graphical window for
plotting data and mathematical functions. """
def __init__(self, width, height, min_x, max_x, min_y, max_y):
""" Initializes the plotter with a window that is
width wide and height high. Its x-axis ranges from
min_x to max_x, and its y-axis ranges from
min_y to max_y. Establishes the global beginning and ending
x values for the plot and the x_increment value.
Draws the x- and y-axes. """
self.pen = Pen() # The plotter object's pen
self.screen = Screen() # The plotter object's screen
self.pen.speed(0) # Speed up rendering
self.screen.tracer(0, 0) # Do not draw pen while drawing
# Establish global x and y ranges
self.min_x, self.max_x = min_x, max_x
self.min_y, self.max_y = min_y, max_y
# Set up window size, in pixels
self.screen.setup(width=width, height=height)
# Set up screen size, in pixels
self.screen.screensize(width, height)
self.screen.setworldcoordinates(min_x, min_y, max_x, max_y)
# x-axis distance that corresponds to one pixel in window distance
self.x_increment = (max_x - min_x)/width
self.draw_grid(20)
self.draw_axes()
self.screen.title("Plot")
self.screen.update()
def __del__(self):
""" Called when the client no longer uses the plotter
object. """
print("Done plotting")
def draw_axes(self, grid=False):
""" Draws the x and y axes within the plotting window.
The grid parameter controls the drawing of accessory
horizontal and vertical lines. """
if grid:
self.draw_grid(20)
self.pen.hideturtle() # Make pen invisible
prev_width = self.pen.width()
self.pen.width(2)
# Draw x axis
self.pen.color('black')
self.draw_arrow(self.min_x, 0, self.max_x, 0)
# Draw y axis
self.draw_arrow(0, self.min_y, 0, self.max_y)
self.pen.width(prev_width)
def draw_grid(self, n):
""" Draws horizontal and vertical accessory reference
coordinate lines on the plot. Parameter n controls
the frequency of the reference lines. """
self.pen.up()
#self.pen.setposition(self.min_x, self.min_y)
inc = (self.max_x - self.min_x)/n
self.pen.color("lightblue")
x = self.min_x
while x <= self.max_x:
self.pen.setposition(x, self.min_y)
self.pen.down()
self.pen.setposition(x, self.max_y)
self.pen.up()
x += inc # Next x
inc = (self.max_y - self.min_y)/n
y = self.min_y
while y <= self.max_y:
self.pen.setposition(self.min_x, y)
self.pen.down()
self.pen.setposition(self.max_x, y)
self.pen.up()
y += inc # Next y
def draw_arrow(self, x1, y1, x2, y2):
""" Draws an arrow starting at (x1, y1) and ending at
(x2, y2). """
# Draw arrow shaft
self.pen.up()
self.pen.setposition(x1, y1) # Move the pen starting point
self.pen.down() # Draw line bottom to top
self.pen.setposition(x2, y2) # Move the pen starting point
# Draw arrow head
dy = y2 - y1
dx = x2 - x1
angle = atan2(dy, dx) *180/pi
self.pen.setheading(angle)
self.pen.stamp()
def plot_function(self, f, color, update=True):
""" Plots function f on the Cartesian coordinate plane
established by initialize_plotter. Plots (x, f(x)),
for all x in the range min_x <= x < max_x.
The color parameter dictates the curve's color. """
# Move pen to starting position
self.pen.up()
self.pen.setposition(self.min_x, f(self.min_x))
self.pen.color(color)
self.pen.down()
# Iterate over the range of x values for min_x <= x < max_x
x = self.min_x
while x < self.max_x:
self.pen.setposition(x, f(x))
x += self.x_increment # Next x
if update:
self.screen.update()
def plot_data(self, data, color, update=True):
""" Plots the (x, y) pairs of values in the data list.
The curve's color is specified by the color parameter. """
# Move pen to starting position
self.pen.up()
self.pen.setposition(data[0][0], data[0][1])
self.pen.color(color)
self.pen.down()
# Plot the points in the data set
for x, y in data:
self.pen.setposition(x, y)
if update:
self.screen.update()
def update(self):
""" Draws any pending plotting actions to the screen. """
self.screen.update()
def setcolor(self, color):
""" Sets the current drawing color. """
self.pen.color(color)
def onclick(self, fun):
""" This method assigns a function to call when the user
clicks the mouse over the plotting window. The
function must accept two integer parameters that
represent the (x, y) location of the mouse when the
click occurred. """
self.screen.onclick(fun)
def interact(self):
""" Places the plotting object in interactive mode so the
user can provide input via the mouse or keyboard. """
self.screen.mainloop()
