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"
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'
def __init__(self,x):
self.it=x
S="D++D++D"
for i in range(self.it):
pesan=""
for j in range(len(S)):
if S[j]=="D":
pesan+="D-D++D-D"
else:
pesan+=S[j]
S=pesan
root3=tk.Tk()
if self.it!=1:
root3.title('Koch Fractal with '+str(self.it)+' iterations')
else:
root3.title('Koch Fractal with an iteration')
self.canvas=ScrolledCanvas(master=root3,width=1000,height=1000)
self.canvas.pack(fill=tk.BOTH,expand=tk.YES)
screen=TurtleScreen(self.canvas)
screen.screensize(10000,10000)
self.turtle=RawTurtle(screen)
self.turtle.ht()
self.turtle.speed(0)
for i in range(len(S)):
if S[i]=="D":
self.turtle.forward(10)
elif S[i]=="+":
self.turtle.right(60)
else:
self.turtle.left(60)
self.canvas.bind('<MouseWheel>',self.zoom)
screen.mainloop()
def create_window(self):
self.root = tk.Tk()
self.canvas = tk.Canvas(self.root,
width=SCREEN_SIZE,
height=SCREEN_SIZE)
self.canvas.pack()
self.wn = TurtleScreen(self.canvas)
self.root.title("Braitenberg's Vehicle #2")
self.wn.onkey(self.start_stop, "space")
self.wn.listen()
self.button_frame = tk.Frame(self.root)
self.button_frame.pack()
self.start_button = tk.Button(self.button_frame,
text="Start",
fg="black",
command=self.start_stop)
self.reset_button = tk.Button(self.button_frame,
text="Reset",
fg="black",
command=self.reset)
self.quit_button = tk.Button(self.button_frame,
text="Quit",
fg="black",
command=self.quit)
self.start_button.pack(side=tk.LEFT)
self.reset_button.pack(side=tk.LEFT)
self.quit_button.pack(side=tk.LEFT)
def __init__(self, parent, levels):
self.levels = levels
# Toggles screen update rate
self.slow_drawing = False
# Draw button
button = Button(parent, text='Draw Fractal', command=self._draw_click)
button.pack()
width, height = (600, 600)
self.canvas = Canvas(parent, width=600, height=600)
# Constrain resizing to a 1:1 aspect ratio
self.canvas.winfo_toplevel().aspect(1, 1, 1, 1)
self.canvas.pack(fill=BOTH, expand=YES)
# Setup a turtle
self.turtleScreen = TurtleScreen(self.canvas)
# 5px of padding
self.turtleScreen.setworldcoordinates(-5, -height - 5, width + 5, 5)
self.turtle = RawTurtle(self.turtleScreen)
self.turtleScreen.colormode(255)
# Listen to resize events
self.canvas.bind('<Configure>', self._resize_and_draw)
# Do an initial draw
self.slow_drawing = True
self._resize_and_draw()
self.slow_drawing = False
def Rank():
root = TK.Tk()
cv1 = TK.Canvas(root, width=400, height=200)
cv1.pack()
s1 = TurtleScreen(cv1)
s1.bgcolor("#42f4ad")
t = RawTurtle(s1)
t.hideturtle()
t.penup()
t.goto(-50,70)
t.write("내가 예측한 1등: "+ guess)
t.goto(-50,50)
if PlayerNumber>=1:
t.write("1등 : "+PlayerRank[0])
t.goto(-50,40)
if PlayerNumber>=2:
t.write("2등 : "+PlayerRank[1])
t.goto(-50,30)
if PlayerNumber>=3:
t.write("3등 : "+PlayerRank[2])
t.goto(-50,20)
if PlayerNumber>=4:
t.write("4등 : "+PlayerRank[3])
t.goto(-50,10)
if PlayerNumber>=5:
t.write("5등 : "+PlayerRank[4])
t.goto(-100,-20)
if(guess==PlayerRank[0]):
t.write("축하드립니다. 1등을 맞추셨습니다.")
else:
t.write("1등을 맞추지 못했습니다.")
def crea_tablero(titulo, alto, ancho):
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
## Crea la ventana y un canvas para dibujar
root = TK.Tk()
root.title(titulo)
canvas = TK.Canvas(root, width=ancho, height=alto)
canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
global fondo_tablero
fondo_tablero = TurtleScreen(canvas)
## Establece el fondo de la pizarra electrónica
canvas["bg"] = "black"
canvas.pack()
global pizarra
pizarra = RawTurtle(fondo_tablero)
dibuja_leds()
## Establece las funciones para capturar las teclas
fondo_tablero.onkeypress(lambda: detiene(), "Escape")
por_siempre()
fondo_tablero.listen()
print("terminó")
root.mainloop()
def init_screen(self):
# intialise screen and turn off auto-render
root = Tk()
root.wm_title(self.window_title)
window = TK.Canvas(master=root, width=self.width, height=self.height)
window.pack()
self.screen = TurtleScreen(window)
self.screen.tracer(0, 0)
def __init__(self):
self.win = tk.Tk()
self.win.geometry("640x400")
self.canvas = Canvas()
self.canvas.pack()
self.scr = TurtleScreen(self.canvas)
self.t = RawTurtle(self.scr)
self.btn = Button(self.win, text="Press me!", command=self.do_action())
self.btn.pack()
def main(pattern: str) -> None:
master = Tk()
canvas = ScrolledCanvas(master)
canvas.pack()
screen = TurtleScreen(canvas)
screen.colormode(255)
turt = RawTurtle(screen)
draw_dots(turt)
turt.pencolor((178, 34, 34))
draw_pattern(turt, pattern)
screen.mainloop()
def initialize(self, hOptions):
self.screen = TurtleScreen(self.tkWidget)
self.tkTurtle = RawTurtle(self.screen)
self.screen.mode('world')
self.tkTurtle.setheading(90)
if 'speed' in hOptions:
self.curSpeed = int(hOptions['speed'])
else:
self.curSpeed = 1
self.lSaveStack = [] # stack to save/restore state on
def construct(self):
"""Constructs graphics."""
self.window = TurtleScreen(self.canvas)
self.window.setworldcoordinates(*__class__._WORLD_COORDS)
self.window.bgcolor(102, 51, 0)
self.peg_dir = []
self.arrow_dir = []
self.graveyard = []
self.path_finder = PathFinder()
self._draw_board()
self._place_pegs()
self._add_callbacks()
def __init__(self, title="Hangman"):
super().__init__()
self.title(title)
self.geometry("720x600")
self.configurationFile = "level.conf"
self.dataFile = "hangman.dat"
self.dataPath = "data/"
self.__hp = HP.THangman(self)
if os.path.exists(self.dataPath + self.dataFile):
self.deserialize()
self.output = tk.StringVar()
self.output.set(self.__hp.getLetters)
self.info = tk.StringVar()
alphabets = 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', \
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Å', 'Ä', 'Ö', '-'
self.Buttons = ButtonsBlock(self, alphabets, 15)
self.Buttons.grid(row=0, column=0, columnspan=3, padx=10, pady=5)
self.frame2 = tk.Frame(self).grid(row=2)
tk.Label(self.frame2, textvariable=self.output).grid(pady=10,
columnspan=5)
self.frame3 = tk.Frame(self).grid(row=3)
tk.Label(self.frame3, textvariable=self.info).grid(padx=10,
pady=10,
columnspan=5,
sticky=tk.W + tk.E)
tk.Button(self, text="Guess a new word",
command=self.new).grid(row=5,
padx=30,
pady=5,
sticky=tk.E + tk.W,
columnspan=5)
self.canvas = Canvas(self, width=500, height=350)
self.canvas.grid(row=8,
column=0,
columnspan=5,
padx=10,
sticky=tk.W + tk.E + tk.S + tk.N)
self.turtle_screen = TurtleScreen(self.canvas)
self.raw_turtle = RawTurtle(self.canvas)
self.raw_turtle.hideturtle()
self.raw_turtle.speed(0)
self.restoreGUI()
message = "You are currently playing in " + levels[
self.__hp.level] + " level"
messagebox.showinfo("Level of difficulty", message)
self.protocol("WM_DELETE_WINDOW", self.close)
def draw(ans):
"""Вывод топологической схемы"""
global xax, moves, oboz, window
turx, tury = xax - int(xax*0.3), int(yax*0.25)
bg_def = window.cget('bg')
canvas = Canvas(window, relief='sunken', borderwidth=5, width=turx, height=tury, background=bg_def)
canvas.place(relx=0.5, rely=0.1, y=int(yax*0.19), anchor=CENTER)
screen = TurtleScreen(canvas)
global turtle
turtle = RawTurtle(canvas)
turtle.speed(5)
turtle.hideturtle()
allen = (turx - int(xax*0.2))
global let
if len(ans) > 7:
if ans[5] == 1 and ans[8] == 1:
let = allen // 3
else:
if ans[5] == 1:
let = allen // 4
elif ans[8] == 1:
let = allen // 4
else:
let = allen // 5
if ans[5] == 2:
allen -= let//2
if ans[8] == 2:
allen -= let//2
else:
if ans[5] == 1:
let = allen // 2
else:
let = allen // 3
if ans[5] == 2:
allen -= let//2
turtle.color('white')
turtle.up()
turtle.goto(x=-allen // 2, y=-int(yax*0.09))
turtle.down()
turtle.color('black')
turtle.dot(5, 'black')
turtle.write('A')
for i in [moves[k + 1][x] for k, x in enumerate(ans) if k + 1 in moves]:
print(i)
eval(i)
def __init__(self, cv):
ts = TurtleScreen(cv)
RawTurtle.__init__(self, ts)
# self.turtleRef = turt
self.ts = ts
ts.listen()
self.isDrawing = False
self.penup()
self.speed(0)
canvas = cv
canvas.bind('<Button-1>', self.onDraw)
canvas.bind('<Button1-ButtonRelease>', self.onStopDrawing)
canvas.bind('<Motion>', self.move)
class TurtleCanvas:
window = tk.Tk()
canvas = ScrolledCanvas(master=window, width=800, height=600)
canvas.pack(fill=tk.BOTH, expand=tk.YES)
screen = TurtleScreen(canvas)
turtle = RawTurtle(screen)
def __init__(self, x, y):
cWidth = 800
cHeight = 600
self.x = x
self.y = y
self.turtle.speed("fastest")
self.window.geometry('%dx%d+%d+%d' % (cWidth, cHeight, x, y))
self.canvas.bind('<MouseWheel>', self.zoom)
def zoom(self, event):
amount = 0.9 if event.delta < 0 else 1.1
self.canvas.scale(tk.ALL, 0, 0, amount, amount)
def square(self, sidelength=50):
for i in range(4):
self.turtle.forward(sidelength)
self.turtle.right(90)
def triangle(self, sidelength=50):
point = self.turtle
point.color("black")
point.speed("fastest")
for i in range(3):
point.forward(sidelength)
point.right(120)
self.window.mainloop()
def star(self, sidelength=50):
point = self.turtle
point.color("black")
point.speed("fastest")
for i in range(5):
point.forward(sidelength)
point.right(145)
self.window.mainloop()
def squareDriver(self, steps):
i = 0
for j in range(steps):
self.square(20 + i)
self.turtle.right(2)
i += 1
def __init__(self):
self.win = Tk()
self.btn = Button(self.win, text="확인", command=self.press)
self.btn.pack()
self.canvas = Canvas(self.win)
self.canvas.config(width=600, height=300)
self.canvas.pack()
self.src = TurtleScreen(self.canvas)
self.t = RawTurtle(self.src)
self.t.pensize(5)
# 서버와 소켓 연결
self.client = socket(AF_INET, SOCK_STREAM)
self.client.connect(('127.0.0.1',9999))
def __init__(self,canvas):
#self.window = master
#self.canvas = ScrolledCanvas(master=self.window, width=800, height=600)
#self.canvas.pack(fill=tk.BOTH, expand=tk.YES)
self.canvas = canvas
self.screen = TurtleScreen(canvas)
self.turtle = RawTurtle(self.screen)
self.turtle.speed("fastest")
#self.window.geometry('%dx%d+%d+%d' % (cWidth, cHeight, x, y))
self.canvas.bind('<MouseWheel>', self.zoom)
self.canvas.bind("<ButtonPress-1>", self.scroll_start)
self.canvas.bind("<B1-Motion>", self.scroll_move)
self.canvas.bind("<ButtonPress-3>", self.changeDirection)
#self.canvas.bind("<c>", self.changeColor)
self.rightDirection = True
def crea_tablero(titulo, alto, ancho):
""" Crea una pizarra electronica
Entradas:
titulo : titulo de la ventana que contendra la pizarra electronica
alto : alto de la ventana en pixeles
ancho : ancho de la ventna en pixeles
Salidas: Ninguna
Restricciones: titulo es una tira, alto y ancho son enteros positivos
"""
## Restricciones
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
## Crea la ventana y un canvas para dibujar
root = TK.Tk()
root.title(titulo)
canvas = TK.Canvas(root, width=ancho, height=alto)
canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
fondo_tablero = TurtleScreen(canvas)
## Establece el fondo de la pizarra electronica
canvas["bg"] = "black"
canvas.pack()
pizarra = RawTurtle(fondo_tablero)
dibuja_leds(pizarra)
## Establece las funciones para capturar las teclas
fondo_tablero.onkeypress(lambda: envie_0(pizarra), "0")
fondo_tablero.onkeypress(lambda: envie_1(pizarra), "1")
fondo_tablero.onkeypress(lambda: envie_2(pizarra), "2")
fondo_tablero.onkeypress(lambda: envie_3(pizarra), "3")
fondo_tablero.onkeypress(lambda: envie_4(pizarra), "4")
fondo_tablero.onkeypress(lambda: envie_5(pizarra), "5")
fondo_tablero.onkeypress(lambda: envie_6(pizarra), "6")
fondo_tablero.onkeypress(lambda: envie_7(pizarra), "7")
fondo_tablero.onkeypress(lambda: envie_8(pizarra), "8")
fondo_tablero.onkeypress(lambda: envie_9(pizarra), "9")
fondo_tablero.onkeypress(lambda: dibuja_leds(pizarra), "Escape")
fondo_tablero.listen()
root.mainloop()
def __init__(self, width, height, borders=wrap):
self.width = width
self.half_width = width // 2
self.height = height
self.half_height = height // 2
self.borders = borders
# intialise screen and turn off auto-render
window = TK.Canvas(width=width, height=height)
window.pack()
self.screen = TurtleScreen(window)
self.screen.tracer(0, 0)
self.fps = 0
self.done = True
self.turtles = []
self.update_freq = 1000 #int(1 / 30.0 * 1000)
def __init__(self,canvas,h,k,xr,yr,size,speed,screensize = 500):
screen = TurtleScreen(canvas)
RawTurtle.__init__(self,screen)
self.screen = screen
self.screen.tracer(0)
self.h = h
self.k = k
self.xr = xr
self.yr = yr
self.size = size
self.speedturt = speed
self.d = 0.05
self.nofunc = 0
self.screensize = screensize
self.hideturtle()
self.pensize(1)
self.reset_var()
def __init__(self, nrOfDiscs, speed):
root = Tk()
root.title("TOWERS OF HANOI")
cv = Canvas(root, width=440, height=210, bg="gray90")
cv.pack()
cv = TurtleScreen(cv)
self.hEngine = HanoiEngine(cv, nrOfDiscs, speed, self.displayMove)
fnt = ("Arial", 12, "bold")
# set attributes: nr of discs, speed; display move count
attrFrame = Frame(root) # contains scales to adjust game's attributes
self.discsLbl = Label(attrFrame, width=7, height=2, font=fnt,
text="")
self.discs = Scale(attrFrame, from_=1, to_=10, orient=HORIZONTAL,
font=fnt, length=0, showvalue=0, repeatinterval=10,
command=self.adjust_nr_of_discs)
self.discs.set(3)
self.tempoLbl = Label(attrFrame, width=8, height=2, font=fnt,
text="")
self.tempo = Scale(attrFrame, from_=1, to_=10, orient=HORIZONTAL,
font=fnt, length=0, showvalue=0, repeatinterval=10,
command=self.adjust_speed)
self.tempo.set(5)
self.moveCntLbl = Label(attrFrame, width=5, height=2, font=fnt,
padx=20, text="", anchor=CENTER)
for widget in (self.discsLbl, self.discs, self.tempoLbl, self.tempo,
self.moveCntLbl):
widget.pack(side=LEFT)
attrFrame.pack(side=TOP)
# control buttons: reset, step, start/pause/resume
ctrlFrame = Frame(root) # contains Buttons to control the game
self.resetBtn = Button(ctrlFrame, width=11, text="reset", font=fnt,
state=DISABLED, padx=15, command=self.reset)
self.stepBtn = Button(ctrlFrame, width=11, text="step", font=fnt,
state=NORMAL, padx=15, command=self.step)
self.startBtn = Button(ctrlFrame, width=11, text="start", font=fnt,
state=NORMAL, padx=15, command=self.start)
for widget in self.resetBtn, self.startBtn:
widget.pack(side=LEFT)
ctrlFrame.pack(side=TOP)
self.state = "START"
root.mainloop()
def __init__(self, titulo, alto, ancho):
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
self.root = TK.Tk()
self.root.title(titulo)
self.canvas = TK.Canvas(self.root, width=ancho, height=alto)
self.canvas.pack()
self.fondo_ventana = TurtleScreen(self.canvas)
self.fondo_ventana.setworldcoordinates(0, alto, ancho, 0)
self.canvas["bg"] = "gold"
self.canvas.pack()
self.pencil = RawTurtle(self.fondo_ventana)
self.pencil.pencolor("white")
def __init__(self, parent):
super().__init__(parent) # Sisuliselt sama kui Tk()
# Määrame rea ja veeru indeksiga 0 kõige kaalukamateks
self.rowconfigure(index=0, weight=1)
self.columnconfigure(index=0, weight=1)
# Tekita lõuend, seo see root objektiga
c = Canvas(self)
# Lõuendi nähtavaks muutmiseks paigutame ta lahtrisse 0,0
c.grid(column=0, row=0, sticky=(N, S, W, E))
# Seo lõuendiga TurtleScreen ja seo TurtleScreeniga konn
self.ts = TurtleScreen(c)
self.algseis()
# Tekitame nuppude paneeli f
f = Frame(self)
f.grid(column=0, row=1)
# Tekita edasiliikumise nupp
b = Button(f, text="Edasi", command=self.edasi)
b.grid(column=0, row=0)
# Tekita vasakpöörde nupp
bv = Button(f, text="Vasakule", command=self.vasakule)
bv.grid(column=1, row=0)
# Tekita parempöörde nupp
bp = Button(f, text="Paremale", command=self.paremale)
bp.grid(column=2, row=0)
# Tekita muutuja kiirus ja sildiga tekstikast kiiruse sisestamiseks
self.kiirus = IntVar()
self.kiirus.set(100)
lbl_kiirus = Label(f, text=" Kiirus: ")
lbl_kiirus.grid(column=3, row=0)
entry_kiirus = Entry(f, textvariable=self.kiirus)
entry_kiirus.grid(column=4, row=0)
# Tekita algseisu nupp
ba = Button(f, text="Algseis", command=self.algseis)
ba.grid(column=5, row=0)
def crea_tablero(titulo, alto, ancho):
""" Crea una pizarra electrónica.
Entradas:
titulo : título de la ventana que contendrá la
pizarra electrónica.
alto : alto de la ventana en pixeles.
ancho : ancho de la ventna en pixeles.
Salidas:
Ninguna.
Restricciones:
titulo es una tira, alto y ancho son enteros positivos.
"""
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
## Crea la ventana y un canvas para dibujar
root = TK.Tk()
root.title(titulo)
canvas = TK.Canvas(root, width=ancho, height=alto)
canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
global fondo_tablero
fondo_tablero = TurtleScreen(canvas)
## Establece el fondo de la pizarra electrónica
canvas["bg"] = "black"
canvas.pack()
global pizarra
pizarra = RawTurtle(fondo_tablero)
dibuja_leds()
## Establece las funciones para capturar las teclas
fondo_tablero.onkeypress(lambda: detiene(), "Escape")
por_siempre()
fondo_tablero.listen()
print("terminó")
root.mainloop()
def __init__(self, titulo, alto, ancho):
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
## Crea la ventana y un canvas para dibujar
self.root = TK.Tk()
self.root.title(titulo)
self.canvas = TK.Canvas(self.root, width=ancho, height=alto)
self.canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
self.fondo_ventana = TurtleScreen(self.canvas)
self.fondo_ventana.setworldcoordinates(0, alto, ancho, 0)
## Establece el color de fondo
self.canvas["bg"] = "blue"
self.canvas.pack()
## Crea una tortuga para dibujar
self.pencil = RawTurtle(self.fondo_ventana)
self.pencil.pencolor("white")
def draw(lines):
from tkinter import Tk, LEFT
from turtle import Canvas, RawTurtle, TurtleScreen
# set up the environment
root = Tk()
canvas = Canvas(root, width=800, height=800)
canvas.pack()
s = TurtleScreen(canvas)
t = RawTurtle(canvas)
t.speed(0)
t.width(1)
for line in lines:
x, y = line[0]
t.up()
t.goto(x * 800 / 1024 - 400, -(y * 800 / 1024 - 400))
for point in line:
t.down()
t.goto(point[0] * 800 / 1024 - 400, -(point[1] * 800 / 1024 - 400))
s.mainloop()
"Figura", " 1. Rectangle\n 2. Square\n 3. Triangle\
\n 4. House\n 5. Doole\n 6. Pattern 1\n 7. Pattern 2\n 8. Circle\n 9. Petal\
\n10.Flower\n11.Shape Change\n 0. Exit or <Enter>")
def param(default, n):
return default if len(ops) == 1 in range(1, n + 1) else ops[n]
from turtle import TurtleScreen, RawTurtle, TK
root = TK.Tk()
root.title("cambio de tamaño")
canvas = TK.Canvas(root, width=1000, height=1000, bg="white")
canvas.pack()
screen = TurtleScreen(canvas)
turtle = RawTurtle(screen)
turtle.shape("turtle")
turtle.speed(5)
while True:
x = getInput()
if x in ["", "0", "00"] or x == None:
break
turtle.reset()
ops = [int(y) for y in x.split()]
x = ops[0]
if x == 1:
rectangulo(100, 50)
elif x == 2:
cuadrado(200)
#!/usr/bin/env python3
## DEMONSTRATES USE OF 2 CANVASES, SO CANNOT BE RUN IN DEMOVIEWER!
"""turtle example: Using TurtleScreen and RawTurtle
for drawing on two distinct canvases.
"""
from turtle import TurtleScreen, RawTurtle, TK
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)
#!/usr/bin/env python3
import socket
from POO import Laby
from tkinter import Tk
from turtle import ScrolledCanvas, TurtleScreen
import io
co = socket.socket()
co.connect((input("IP : "), 1337))
log = bytes()
while True:
_ = co.recv(1)
if len(_) == 0:
break
else:
log += _
log = io.StringIO(log.decode())
main = Tk()
can = ScrolledCanvas(main)
can.pack(fill="both", expand=True)
sc = TurtleScreen(can)
laby = Laby(can, sc, log)
main.mainloop()
