class Line:
pen = turtle.RawPen(g)
pen.color("white")
pen.hideturtle()
pen.speed(0)
def __init__(self, begin, end):
#begin and end should be tuples
self.begin = begin
self.end = end
self.slope = (end[1] - begin[1]) / (end[0] - begin[0])
self.yint = begin[1] - self.slope * begin[0]
def intersect(self, line):
1
def draw(self):
self.pen.up()
self.pen.goto(scalingFactor * self.begin[0],
scalingFactor * self.begin[1] + yOffset)
self.pen.down()
self.pen.goto(scalingFactor * self.end[0],
scalingFactor * self.end[1] + yOffset)
self.pen.up()
def write_score(self):
self.pen = turtle.RawPen(self.turt_screen)
self.pen.speed(0)
self.pen.color("black")
self.pen.penup()
self.pen.hideturtle()
self.pen.goto(0, 300)
class Point:
pen = turtle.RawPen(g)
pen.color("white")
pen.hideturtle()
pen.speed(0)
def __init__(self, x, y, flag=None, date=0):
self.x = x
self.y = y
self.flag = flag
self.date = date
def draw(self):
x = self.x * scalingFactor
y = self.y * scalingFactor + yOffset
if self.flag == "close":
self.pen.color("red")
elif self.flag == "open":
self.pen.color("green")
width = 4
self.pen.up()
self.pen.goto(x - width / 2, y + width / 2)
self.pen.down()
self.pen.goto(x + width / 2, y + width / 2)
self.pen.goto(x + width / 2, y - width / 2)
self.pen.goto(x - width / 2, y - width / 2)
self.pen.goto(x - width / 2, y + width / 2)
self.pen.up()
class Box:
pen = turtle.RawPen(g)
pen.color("orange")
pen.hideturtle()
pen.speed(0)
def __init__(self, high, low, leftSide, rightSide):
self.high = high
self.low = low
self.leftSide = leftSide
self.rightSide = rightSide
self.line = BoxLine((leftSide, low), (rightSide, high))
def draw(self):
high = self.high * scalingFactor + yOffset
low = self.low * scalingFactor + yOffset
leftSide = self.leftSide * scalingFactor
rightSide = self.rightSide * scalingFactor
self.pen.up()
self.pen.goto(leftSide, high)
self.pen.down()
self.pen.goto(rightSide, high)
self.pen.goto(rightSide, low)
self.pen.goto(leftSide, low)
self.pen.goto(leftSide, high)
self.pen.up()
self.line.draw()
def __init__(self, canvas):
self.pencilBox = ["black", "red", "green", "blue"]
self.canvas = canvas
self.yurtle = turtle.RawPen(self.canvas)
self.yurtle.degrees()
self.selectPen(0)
self.penUp()
def display(self, spread=200, node_size=20):
'''(spread, nodeSize) where spread is the radius of the inner circle, and nodeSize is the radius of node's'''
screen = turtle.Screen() # Create a screen
turtle.TurtleScreen._RUNNING = True
pen = turtle.RawPen(screen) # Create a turtle
pen.speed(10000) # Fast moving
screen.tracer(0, 0) # Don't update until told.
node_coordinates = {} # FORMAT: {node = Vec2}
num_nodes = len(self.__nodes)
for i, node in enumerate(self.__nodes):
# DRAWING
pen.pu() # Pick up pen
pen.home() # Move to center of screen
current_node_percent = i / num_nodes # Percentage of way through nodes at i index
pen.left(current_node_percent * 360) # Rotate that percent through the circle
pen.forward(spread) # Move spread px out from center
pen.seth(0) # Reset angle
pen.pd() # Start Drawing
pen.circle(node_size) # Draw circle with radius nodeSize
# SAVE INFORMATION
pen.pu() # Stop drawing
pen.sety(pen.ycor() + node_size) # Move to center of circle
node_coordinates[node] = pen.position() # save coordinates
if self.__debug:
print(node_coordinates[node]) # Print for debugging
pen.sety(pen.ycor() - 4)
pen.write(node, align="center") # Write contents of node to string.
for edge in self.__edges:
if self.__debug:
print(edge) # Print for debugging
pen.pu() # Stop Drawing
pen.setpos(node_coordinates[edge[0]]) # Go to center of node_a
pen.seth(pen.towards(node_coordinates[edge[1]])) # Look at node_b
pen.forward(node_size) # Move to edge of node_a's circle
pen.pd() # Start Drawing
# Move towards node_b, stopping 10 px before you reach coordinates
if not self.__isWeighted:
pen.forward(math.sqrt(
(pen.position() - node_coordinates[edge[1]])[0] ** 2 + (pen.position() - node_coordinates[edge[1]])[
1] ** 2) - node_size)
else:
pen.forward((math.sqrt(
(pen.position() - node_coordinates[edge[1]])[0] ** 2 + (pen.position() - node_coordinates[edge[1]])[
1] ** 2) - node_size) / 2) # Move halfway
pen.write(edge[2]) # Display edge weight
pen.forward(math.sqrt(
(pen.position() - node_coordinates[edge[1]])[0] ** 2 + (pen.position() - node_coordinates[edge[1]])[
1] ** 2) - node_size)
pen.pu() # Stop drawing
pen.ht() # Hide turtle
screen.update() # Display results
screen.exitonclick()
screen = None
del pen
def __create_new_line(self, type, str=None):
if len(self.infomation_bars) == 0:
self.__information_point = LEFT_BUTTON.copy()
else:
self.__information_point[1] += WORD_SIZE
if str is None:
str = 'None'
self.infomation_bars[type] = turtle.RawPen(turtle.getcanvas())
self.infomation_bars[type].ht()
self.infomation_bars[type].pu()
self.infomation_bars[type].speed(0)
self.infomation_bars[type].goto(self.__information_point[0],
self.__information_point[1])
self.infomation_bars[type].write(type + ': ' + str)
def __get_step(self):
global line_turtle, line
line = 0
turtle.listen()
line_turtle = turtle.RawPen(turtle.getcanvas())
line_turtle.pu()
line_turtle.speed(0)
line_turtle.ht()
line_turtle.goto(-440, 400)
line_turtle.write('Now is line 0')
self.command_iter = Iter(self.command_list)
self.parameters_iter = Iter(self.parameters_list)
turtle.onkeypress(self.__undo, 'Down')
turtle.onkeypress(self.__run_step, 'Up')
def menu():
global turtle, window, entry
window = Tk()
window.resizable(0, 0)
window.title('Polygons')
window.wm_attributes('-topmost', 1)
entry = Entry(window, relief='solid', width=15, font=('Arial', 20))
entry.pack()
start_button = Button(window,
text='POLYGON',
font=('Arial', 20, 'bold'),
foreground='blue',
background='white',
relief='solid',
width=10,
activebackground='white',
activeforeground='blue')
button_exit = Button(window,
text='EXIT',
font=('Arial', 20, 'bold'),
foreground='red',
background='white',
relief='solid',
width=10,
activebackground='white',
activeforeground='red')
button_star = Button(window,
text='STAR',
font=('Arial', 20, 'bold'),
foreground='yellow',
background='white',
relief='solid',
width=10,
activebackground='white',
activeforeground='yellow')
start_button.pack()
start_button.bind('<Button-1>', draw)
button_exit.bind_all('<Escape>', close_window)
button_star.pack()
button_exit.bind('<Button-1>', close_window)
button_exit.pack()
button_star.bind('<Button-1>', draw_star)
canvas = Canvas(window, width=400, height=400)
canvas.pack()
turtle = turtle.RawPen(canvas)
window.mainloop()
def __init__(self, display_maze, shape="turtle", color="black", fill="green"):
# Capture information from display_maze function needed to position robot
self.window = display_maze
self.cell_size = self.window.get_cell_size()
self.origin = self.window.get_origin() + (self.cell_size // 2)
# Configure pen
self.pen = turtle.RawPen(self.window.get_window())
self.pen.hideturtle()
self.pen.penup()
self.pen.setheading(90)
self.pen.goto(self.origin, self.origin)
self.pen.shape(shape)
self.pen.color(color)
self.pen.fillcolor(fill)
self.pen.showturtle()
self.stamp = self.pen.stamp()
def draw_maze(self):
'''
This function uses Python's turtle library to draw a picture of the maze
given as an argument when running the script.
'''
# configure turtle for maze drawing
wally = turtle.RawPen(self.window)
wally.speed(0)
wally.hideturtle()
wally.penup()
# iterate through squares one by one to decide where to draw walls
for x in range(self.maze.dim):
for y in range(self.maze.dim):
if not self.maze.is_permissible([x, y], 'up'):
wally.goto(self.origin + self.sq_size * x,
self.origin + self.sq_size * (y + 1))
wally.setheading(0)
wally.pendown()
wally.forward(self.sq_size)
wally.penup()
if not self.maze.is_permissible([x, y], 'right'):
wally.goto(self.origin + self.sq_size * (x + 1),
self.origin + self.sq_size * y)
wally.setheading(90)
wally.pendown()
wally.forward(self.sq_size)
wally.penup()
# only check bottom wall if on lowest row
if y == 0 and not self.maze.is_permissible([x, y], 'down'):
wally.goto(self.origin + self.sq_size * x, self.origin)
wally.setheading(0)
wally.pendown()
wally.forward(self.sq_size)
wally.penup()
# only check left wall if on leftmost column
if x == 0 and not self.maze.is_permissible([x, y], 'left'):
wally.goto(self.origin, self.origin + self.sq_size * y)
wally.setheading(90)
wally.pendown()
wally.forward(self.sq_size)
wally.penup()
t.circle(4*i)
File "C:\Python37\lib\turtle.py", line 1990, in circle
self.speed(speed)
File "C:\Python37\lib\turtle.py", line 2174, in speed
self.pen(speed=speed)
File "C:\Python37\lib\turtle.py", line 2459, in pen
self._update()
File "C:\Python37\lib\turtle.py", line 2663, in _update
screen._delay(screen._delayvalue) # TurtleScreenBase
File "C:\Python37\lib\turtle.py", line 566, in _delay
self.cv.after(delay)
File "C:\Python37\lib\tkinter\__init__.py", line 744, in after
self.tk.call('after', ms)
KeyboardInterrupt
>>> t.reset()
>>> turtle.RawPen()
Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
turtle.RawPen()
File "C:\Python37\lib\turtle.py", line 2538, in __init__
raise TurtleGraphicsError("bad canvas argument %s" % canvas)
turtle.TurtleGraphicsError: bad canvas argument None
>>> import turtle
>>> turtle.RawPen()
Traceback (most recent call last):
File "<pyshell#34>", line 1, in <module>
turtle.RawPen()
File "C:\Python37\lib\turtle.py", line 2538, in __init__
raise TurtleGraphicsError("bad canvas argument %s" % canvas)
turtle.TurtleGraphicsError: bad canvas argument None
>>>
def __init__(self, set_width=1000, set_height=1000):
self.window = Tk()
canvas = Canvas(self.window, width=set_width, height=set_height)
canvas.pack()
self.cursor = turtle.RawPen(canvas)
self.cursor.speed(1)
def __init__(self, canvas):
super().__init__(canvas)
self.my_turtle = turtle.RawPen(self.canvas)
self.my_turtle.degrees()
self.selectPen(0)
self.penUp()
def __init__(self, canvas):
super().__init__(canvas)
self.test_string = ""
self.cursor = turtle.RawPen(self._canvas)
self.penIsDown = False
self.cursor.speed(1)
class BoxLine(Line):
pen = turtle.RawPen(g)
pen.color("orange")
pen.hideturtle()
pen.speed(0)
t2.pendown()
elif splited[0] == 'up':
t2.penup()
elif splited[0] == 'clear':
t2.clear()
else:
es.msgbox("NameError: name " + splited[0] + "' is not defined",
'Error')
r = tu._Root()
r.set_geometry(800, 800, 0, 0)
cv2 = tu.ScrolledCanvas(r)
cv2.pack(expand=True, fill=tk.BOTH)
cv2.reset(400, 4000)
t1 = tu.RawPen(cv2)
cv3 = tu.ScrolledCanvas(r)
cv3.pack(expand=True, fill=tk.BOTH)
cv3.reset(400, 400)
t2 = tu.RawPen(cv3)
t2.shape('turtle')
t1.hideturtle()
t1.penup()
t1.goto(-350, 100)
t1.color('green')
t1.write('''
_____ __
| __ \ / _|
| |__) | _| |_ __ _ _ __ __ _
| ___/ | | | _/ _` | '_ \ / _` |
| | | |_| | || (_| | | | | (_| |
def __init__(self):
self.this_canvas = GuiInterface.canvas
self.cursor = turtle.RawPen(self.this_canvas)
self.cursor.speed(1)
import turtle
from tkinter import *
tk = Tk()
tk.resizable(0, 0)
tk.title('Wielokaty')
tk.wm_attributes('-topmost', 1)
canvas = Canvas(tk, width=400, height=400)
canvas.pack()
turtle = turtle.RawPen(canvas)
tk.mainloop()
Date.append(each[0])
Open.append(float(each[1]))
High.append(float(each[2]))
Low.append(float(each[3]))
Close.append(float(each[4]))
g = turtle.Screen()
g.title("Indicator E")
g.bgcolor("black")
g.setup(width=1000, height=700)
g.screensize(2000, 20000)
scalingFactor = .2
yOffset = -5000
pen = turtle.RawPen(g)
pen.color("white")
pen.hideturtle()
pen.speed(0)
pen.up()
pen.goto(-990, 340)
pen.down()
pen.goto(-990, -330)
pen.goto(-990, 0)
#pen.goto(990,0)
pen.up()
############################################
x, y = ob.position()
ob.down()
ob.goto(obs[dis_list[0][0]].position())
ob.goto(x, y)
ob.up()
ob.clear()
return
root = tk.Tk()
root.title("Turtle")
root.geometry('800x640')
cv = tk.Canvas(root, bg='white', height=800, width=640)
cv.pack()
a = turtle.RawPen(cv)
b = turtle.RawPen(cv)
c = turtle.RawPen(cv)
d = turtle.RawPen(cv)
i = [a, b, c, d]
for ob in i:
ob.up()
ob.setpos(getRandomPos()) # 随机放置多个海龟在画布上
'''
向中心随机移动
'''
while True:
towardPoint(0, 0, a, b, c, d) #朝向共同点
#随机前进和后退
if randomstat:
5: 'body',
4: 'arm',
3: 'arm',
2: 'leg',
1: 'leg'
}
# Tell players how many letters the host_word has and new blank lines so the other players can't see the answer
for i in range(20):
print('\n')
print('The host has chosen a word with ' + str(len(host_word)) +
' letters in it')
# Show screen and define "pen"
screen = turtle.Screen()
drawing_pen = turtle.RawPen(screen)
drawing_pen.hideturtle()
# For 100 times, if there isn't a clear winner or loser continue asking for letters and running turns
for i in range(100):
if not player_won(correct_guesses) and not player_lost(n_pieces_left):
guess = input(
'Please type the letter you think is in the hosts word: ')
# Checks if input is in alphabet and only one character (one letter) for 100 times,
# then exits program if user persists
for ii in range(100):
if not guess.isalpha() or len(guess) > 1 or len(guess) == 0:
guess = input(
'Please remember to only type 1 letter. '
'Not a number, not a phrase, just a letter. Try again! ')
def send_letter(event=None):
global text_prompt
global input_win
global sub_button
global out_win
global guess_letter
global f_letter
global empty_guess2
global rand_word
global fill_guess
global num
global level
global counter
global binned
global bins
global guessed
f_letter = guess_letter.get()
while True:
if len(f_letter) != 1:
input_win.delete(0, END)
text_prompt.grid_forget()
out_win.grid_forget()
text_prompt = Label(root, text="Max 1 letter.", width=30)
text_prompt.grid(row=0, column=0, padx=15)
input_win.grid_forget()
input_win = Entry(root, textvariable=guess_letter, width=30, justify=CENTER)
input_win.grid(row=1, column=0, padx=15)
input_win.focus_set()
input_win.bind('<Return>', send_letter)
sub_button = Button(root, text="Submit", command=send_letter)
sub_button.grid(row=2, column=0, padx=15)
out_win = Label(root, relief=SUNKEN, text=fill_guess, width=30)
out_win.grid(row=3, column=0, padx=15)
break
if f_letter in rand_word:
for i in rand_word:
lst = [i for i, n in enumerate(rand_word) if n == f_letter]
for e in lst:
empty_guess2[e] = f_letter
input_win.delete(0, END)
if list(rand_word) == empty_guess2:
fill_guess = "".join(empty_guess2)
again = messagebox.askyesno("New game?", "Correct, answer is " + fill_guess + "\nDo you wish to play again??")
if again == 1:
loop()
return False
if again == 0:
raise SystemExit
fill_guess = "".join(empty_guess2)
input_win.delete(0, END)
text_prompt.grid_forget()
out_win.grid_forget()
text_prompt = Label(root, text="Guess a letter.", width=30)
text_prompt.grid(row=0, column=0, padx=15)
input_win.grid_forget()
input_win = Entry(root, textvariable=guess_letter, width=30, justify=CENTER)
input_win.grid(row=1, column=0, padx=15)
input_win.focus_set()
input_win.bind('<Return>', send_letter)
sub_button = Button(root, text="Submit", command=send_letter)
sub_button.grid(row=2, column=0, padx=15)
out_win = Label(root, relief=SUNKEN, text=fill_guess, width=30)
out_win.grid(row=3, column=0, padx=15)
break
else:
if f_letter.upper() not in bins:
bins.append(guess_letter.get())
bins = [b.capitalize() for b in bins]
binned = " ".join(bins)
fill_guess = "".join(empty_guess2)
input_win.delete(0, END)
text_prompt.grid_forget()
out_win.grid_forget()
guessed.grid_forget()
text_prompt = Label(root, text="Wrong guess. Guess a letter.", width=30)
text_prompt.grid(row=0, column=0, padx=15)
input_win.grid_forget()
input_win = Entry(root, textvariable=guess_letter, width=30, justify=CENTER)
input_win.focus_set()
input_win.bind('<Return>', send_letter)
input_win.grid(row=1, column=0, padx=15)
sub_button = Button(root, text="Submit", command=send_letter)
sub_button.grid(row=2, column=0, padx=15)
out_win = Label(root, relief=SUNKEN, text=fill_guess, width=30)
out_win.grid(row=3, column=0, padx=15)
counter += 1
guessed = Label(root, width=30, text=binned)
guessed.grid(row=4, column=0, padx=15)
if counter == 1:
shape1 = turtle.RawPen(canvas)
shape1.speed(0)
shape1.shape("square")
shape1.color("black")
shape1.shapesize(stretch_wid=1, stretch_len=7)
shape1.penup()
shape1.goto(-30, -180)
if counter == 2:
shape2 = turtle.RawPen(canvas)
shape2.speed(0)
shape2.shape("square")
shape2.color("black")
shape2.shapesize(stretch_wid=15, stretch_len=1)
shape2.penup()
shape2.goto(-80, -20)
if counter == 3:
shape3 = turtle.RawPen(canvas)
shape3.speed(0)
shape3.shape("square")
shape3.color("black")
shape3.shapesize(stretch_wid=1, stretch_len=9)
shape3.penup()
shape3.goto(0, 140)
if counter == 4:
shape4 = turtle.RawPen(canvas)
shape4.speed(0)
shape4.left(45)
shape4.shape("square")
shape4.color("black")
shape4.shapesize(stretch_wid=1, stretch_len=3)
shape4.penup()
shape4.goto(-55, 115)
if counter == 5:
shape5 = turtle.RawPen(canvas)
shape5.speed(0)
shape5.shape("square")
shape5.color("black")
shape5.shapesize(stretch_wid=4, stretch_len=1)
shape5.penup()
shape5.goto(40, 105)
if counter == 6:
shape6 = turtle.RawPen(canvas)
shape6.speed(0)
shape6.shape("circle")
shape6.color("black")
shape6.shapesize(stretch_wid=2, stretch_len=2)
shape6.penup()
shape6.goto(40, 60)
if counter == 7:
shape7 = turtle.RawPen(canvas)
shape7.speed(0)
shape7.shape("square")
shape7.color("black")
shape7.shapesize(stretch_wid=4, stretch_len=1)
shape7.penup()
shape7.goto(40, 0)
if counter == 8:
shape8 = turtle.RawPen(canvas)
shape8.left(45)
shape8.speed(0)
shape8.shape("square")
shape8.color("black")
shape8.shapesize(stretch_wid=3, stretch_len=1)
shape8.penup()
shape8.goto(65, 10)
if counter == 9:
shape9 = turtle.RawPen(canvas)
shape9.right(45)
shape9.speed(0)
shape9.shape("square")
shape9.color("black")
shape9.shapesize(stretch_wid=3, stretch_len=1)
shape9.penup()
shape9.goto(15, 10)
if counter == 10:
shape10 = turtle.RawPen(canvas)
shape10.left(30)
shape10.speed(0)
shape10.shape("square")
shape10.color("black")
shape10.shapesize(stretch_wid=4, stretch_len=1)
shape10.penup()
shape10.goto(60, -70)
if counter == 11:
shape11 = turtle.RawPen(canvas)
shape11.right(30)
shape11.speed(0)
shape11.shape("square")
shape11.color("black")
shape11.shapesize(stretch_wid=4, stretch_len=1)
shape11.penup()
shape11.goto(20, -70)
if counter == 12:
again = messagebox.askyesno("New game?",
"Correct, answer is " + rand_word + "\nDo you wish to play again??")
if again == 1:
loop()
counter = 0
canvas.delete("all")
return False
if again == 0:
raise SystemExit
break
def __init__(self):
self.pen = turtle.RawPen(get_canvas())
self.pen.degrees()
self._all_turtles.append(weakref.ref(self))
self._count = self._turtle_count
self.__class__._turtle_count += 1
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 11 07:21:17 2016
@author: Backup
"""
p = (180 - 135)
i = (100)
import turtle
turtle.RawPen(turtle.Screen())
turtle.color("red", "blue")
turtle.pu()
turtle.setpos(-i / 2, i + 20)
turtle.pd()
turtle.fill(True)
for b in range(0, 8, 1):
turtle.fd(i)
turtle.right(p)
turtle.fill(False)
turtle.pu()
turtle.setpos(-70, 20)
turtle.right(p - 45)
turtle.pd()
turtle.write("Timmy is a Teacher now", True, "left",
("Times New Roman", 12, "normal"))
def __init__(self, ):
self.test_string = ''
self.cursor = turtle.RawPen(self.this_canvas)
self.cursor.speed(1)
