class Material(object):
def __init__(self):
self.gods_hand = Turtle()
self.gods_hand.hideturtle()
self.gods_hand.speed(0)
def draw_line(self):
self.gods_hand.penup()
self.gods_hand.tracer(0, 0)
self.gods_hand.goto(100, 100)
self.gods_hand.pendown()
self.gods_hand.fill(True)
self.gods_hand.setheading(0)
self.gods_hand.forward(50)
self.gods_hand.setheading(90)
self.gods_hand.forward(50)
self.gods_hand.setheading(180)
self.gods_hand.forward(50)
self.gods_hand.setheading(270)
self.gods_hand.forward(50)
self.gods_hand.fill(False)
self.gods_hand.penup()
self.gods_hand.goto(120, 120)
self.gods_hand.pendown()
self.gods_hand.pencolor("Blue")
self.gods_hand.fillcolor("Blue")
self.gods_hand.fill(True)
self.gods_hand.setheading(0)
self.gods_hand.forward(10)
self.gods_hand.setheading(90)
self.gods_hand.forward(10)
self.gods_hand.setheading(180)
self.gods_hand.forward(10)
self.gods_hand.setheading(270)
self.gods_hand.forward(10)
self.gods_hand.fill(False)
self.gods_hand.penup()
self.gods_hand.tracer(1, 1)
def build_box(self, pos_x, pos_y, length_x, length_y, do_fill, color):
pos_x, pos_y = coordinate_converter((pos_x, pos_y))
self.gods_hand.tracer(0, 0)
self.gods_hand.penup()
self.gods_hand.goto(pos_x, pos_y)
self.gods_hand.pendown()
if do_fill:
self.gods_hand.fill(True)
self.gods_hand.color(color)
for x in range(4, 0, -1):
heading = x * 90
self.gods_hand.setheading(heading)
self.gods_hand.forward(length_x)
if do_fill:
self.gods_hand.fill(False)
self.gods_hand.tracer(1, 1)
def draw_human(self, pos_x, pos_y):
self.gods_hand.tracer(0, 0)
self.gods_hand.penup()
self.gods_hand.goto(pos_x, pos_y)
self.gods_hand.color("blue")
self.gods_hand.shape("circle")
self.gods_hand.shapesize(0, 0, 5)
stampid = self.gods_hand.stamp()
self.gods_hand.color("black")
self.gods_hand.tracer(1, 1)
return stampid
def erase_human(self, stampid):
self.gods_hand.clearstamp(stampid)
def main():
p = Turtle()
p.color("green")
p.pensize(3)
#p.setundobuffer(None)
p.hideturtle() #Make the turtle invisible. It’s a good idea to do this while you’re in the middle of doing some complex drawing,
#because hiding the turtle speeds up the drawing observably.
#p.speed(10)
# p.getscreen().tracer(1,0)#Return the TurtleScreen object the turtle is drawing on.
p.speed(10)
#TurtleScreen methods can then be called for that object.
p.left(90)# Turn turtle left by angle units. direction 调整画笔
p.penup() #Pull the pen up – no drawing when moving.
p.goto(0, -80)#Move turtle to an absolute position. If the pen is down, draw line. Do not change the turtle’s orientation.
p.pendown()# Pull the pen down – drawing when moving. 这三条语句是一个组合相当于先把笔收起来再移动到指定位置，再把笔放下开始画
#否则turtle一移动就会自动的把线画出来
#t = tree([p], 200, 65, 0.6375)
t = tree([p], 200, 65, 0.6375)
p.penup() #Pull the pen up – no drawing when moving.
p.home()
p.goto(0, 80)
p.pendown()# P
p.right(90);
t1 = tree([p], 200, 65, 0.6375)
class Lampe():
lyser = False
turtle = None
def lag_skilpadde(self):
""" Lager en egen skilpadde for denne lamen."""
self.turtle = Turtle()
self.turtle.penup()
self.turtle.hideturtle()
# Gult lys når vi lyser.
self.turtle.shape('circle')
self.turtle.color('yellow')
self.turtle.shapesize(5)
def slaa_paa(self):
self.lyser = True
self.turtle.showturtle()
def slaa_av(self):
self.lyser = False
self.turtle.hideturtle()
def init_drawman():
''' Инициализация черепашки '''
global t, x_current, y_current, _drawman_scale
shag=50
vod=0.5
t = Turtle()
t.penup()
x_current = 0
y_current = 0
t.goto(x_current, y_current)
drawman_scale(shag,vod)
t.penup()
t.goto(-300,250)
t.color("red")
y=-250
x=-300
while x<=300:
t.pendown()
t.goto(x,-250)
t.penup()
x+=shag
t.goto(x,250)
t.goto(300,250)
y=250
x=300
while y>=-250:
t.pendown()
t.goto(-300,y)
t.penup()
y-=shag
t.goto(300,y)
def draw_loop(turtle: Turtle, side: int, angle: int) -> None:
colors = ['red', 'green', 'blue', 'purple']
a = 0
while True:
turtle.left(angle % 24)
turtle.forward(side)
angle += 1
a += 1
turtle.color(colors[a % len(colors)])
def maketree(x, y):
p = Turtle()
p.color("green")
p.pensize(5)
p.hideturtle()
#p.getscreen().tracer(30)
p.speed(10)
p.left(90)
p.penup()
p.goto(x, y)
p.pendown()
t = tree([p], 110, 65, 0.6375)
def main():
side = float(input('Enter a side length: '))
turtle = Turtle()
turtle.penup()
turtle.setx(-side / 2)
turtle.sety(side / 2)
turtle.pendown()
turtle.speed('slowest')
turtle.color('green')
turtle.pensize(5)
for i in range(4):
turtle.forward(side)
turtle.right(90)
done()
def draw_art():
window = Screen()
window.bgcolor('cyan')
angie = Turtle()
angie.shape('turtle')
angie.color('blue')
angie.speed(2000)
# angie.left(105)
for j in range(80):
angie.right(5)
draw_rhombus(angie, 100)
angie.left(90)
angie.forward(300)
# Close window
window.exitonclick()
def draw_telerik_logo(turtle: Turtle, side: int) -> None:
turtle.color('green')
turtle.penup()
turtle.setpos(-side * 1.5, side)
turtle.pendown()
turtle.left(45)
turtle.forward(side)
turtle.right(90)
turtle.forward(side * 2)
turtle.right(90)
for _ in range(2):
turtle.forward(side)
turtle.right(90)
turtle.forward(side * 2)
turtle.right(90)
turtle.forward(side)
def main():
# creating a window
window = Screen()
# window.bgcolor("orange")
remo = Turtle()
remo.shape("turtle")
remo.color("green")
remo.speed(50)
for i in range(36):
remo.circle(100)
remo.left(10)
remo.color("red")
for i in range(36):
remo.circle(80)
remo.left(10)
remo.color("yellow")
for i in range(36):
remo.circle(60)
remo.left(10)
window.exitonclick()
def draw_olympics_logo(turtle: Turtle, radius: int) -> None:
x_coord = -radius * 3
x_subtract = radius + 20
colors = ['blue', 'yellow', 'red', 'green', 'black']
for i in range(0, len(colors), 2):
turtle.penup()
turtle.setpos(x_coord, 0)
turtle.pendown()
turtle.color(colors[i])
turtle.circle(radius)
x_coord += x_subtract
if i + 1 != len(colors):
turtle.penup()
turtle.setpos(x_coord, -radius)
turtle.pendown()
turtle.color(colors[i + 1])
turtle.circle(radius)
x_coord += x_subtract
class Politician:
def __init__(self, x, y):
self.x = x
self.y = y
self.turtle = Turtle()
self.turtle.color('black')
self.turtle.penup()
self.turtle.goto(x, y)
self.turtle.pendown()
self.votes = 0
self.wins = 0
def readjust_after_election(self, win, winner):
if win == True:
self.turtle.color('green')
else:
self.turtle.color('red')
self.x = winner.x*0.5 + self.x*0.5
self.y = winner.y*0.5 + self.y*0.5
self.turtle.goto(self.x, self.y)
def add_segment(self, position):
new_turtle = Turtle('square')
new_turtle.color('white')
new_turtle.penup()
new_turtle.goto(position)
self.segments.append(new_turtle)
tl.forward(20)
tl.left(120)
tl.forward(20)
tl.right(48)
tl.forward(20)
tl.left(120)
tl.forward(20)
tl.right(48)
tl.forward(20)
tl.left(120)
tl.forward(20)
tl.right(48)
tl.forward(20)
tl.left(120)
tl.forward(20)
tl.end_fill()
size = 300
tl.hideturtle()
tl.penup()
tl.color('green')
tl.goto(0, -size / 2)
tl.setheading(90)
tl.pendown()
tl.speed(0)
draw_fractal(size)
turtle.done()
#!/usr/bin/python
# coding: utf-8
from turtle import Screen
from turtle import Turtle
s = Screen()
s.bgcolor('black')
ikea_lys = Turtle()
bestemors_lys = Turtle()
ikea_lys.shape('circle')
ikea_lys.color('black')
ikea_lys.shapesize(3)
bestemors_lys.shape('circle')
bestemors_lys.color('black')
bestemors_lys.shapesize(3)
class Lampe():
lyser = False
turtle = None
def lag_skilpadde(self):
""" Lager en egen skilpadde for denne lamen."""
self.turtle = Turtle()
self.turtle.penup()
self.turtle.hideturtle()
# Gult lys når vi lyser.
class ParsonTurtle(Turtle):
def __init__(self):
self._turtle = Turtle()
self._turtle.shape('turtle')
self._commands = []
def forward(self, dist, log=True):
self._turtle.forward(dist)
if log:
self._commands.append("fwd" + str(dist))
def fd(self, dist, log=True):
return self.forward(dist, log=log)
def backward(self, dist, log=True):
self._turtle.backward(dist)
if log:
self._commands.append("bwd" + str(dist))
def back(self, dist, log=True):
return self.backward(dist, log=log)
def bk(self, dist, log=True):
return self.backward(dist, log=log)
def left(self, angle, log=True):
self._turtle.left(angle)
if log:
self._commands.append("lt" + str(angle))
def lt(self, angle, log=True):
return self.left(angle, log=log)
def right(self, angle, log=True):
self._turtle.right(angle)
if log:
self._commands.append("rt" + str(angle))
def rt(self, angle, log=True):
return self.right(angle, log=log)
def goto(self, nx, ny, log=True):
self._turtle.goto(nx, ny)
if log:
self._commands.append("gt" + str(nx) + "-" + str(ny))
def setposition(self, nx, ny, log=True):
self._turtle.setposition(nx, ny)
if log:
self._commands.append("setpos" + str(nx) + "-" + str(ny))
def setpos(self, nx, ny, log=True):
return self.setposition(nx, ny, log=log)
def setx(self, nx, log=True):
self._turtle.setx(nx)
if log:
self._commands.append("setx" + str(nx))
def sety(self, ny, log=True):
self._turtle.sety(ny)
if log:
self._commands.append("sety" + str(ny))
def dot(self, size, color, log=True):
self._turtle.dot(size, color)
if log:
self._commands.append("dot" + str(size) + "-" + str(color))
def circle(self, radius, extent, log=True):
self._turtle.circle(radius, extent)
if log:
self._commands.append("circle" + str(radius) + "-" + str(extent))
def up(self, log=True):
self._turtle.up()
if log:
self._commands.append("up")
def penup(self, log=True):
return self.up(log=log)
def pu(self, log=True):
return self.up(log=log)
def down(self, log=True):
self._turtle.down()
if log:
self._commands.append("down")
def pendown(self, log=True):
return self.down(log=log)
def pd(self, log=True):
return self.down(log=log)
def speed(self, spd):
self._turtle.speed(spd)
def _logColorChange(self, command, color, green, blue):
if blue is not None:
self._commands.append("%s(%d, %d, %d)"%(command, color, green, blue))
else:
self._commands.append("%s(%s)"%(command, color))
def pencolor(self, color, green=None, blue=None, log=True):
if blue is not None:
self._turtle.pencolor(color, green, blue)
else:
self._turtle.pencolor(color)
if log:
self._logColorChange("pcolor", color, green, blue)
def color(self, color, green=None, blue=None, log=True):
if blue is not None:
self._turtle.color(color, green, blue)
else:
self._turtle.color(color)
if log:
self._logColorChange("color", color, green, blue)
def fillcolor(self, color, green=None, blue=None, log=True):
if blue is not None:
self._turtle.fillcolor(color, green, blue)
else:
self._turtle.fillcolor(color)
if log:
self._logColorChange("fcolor", color, green, blue)
def width(self, size, log=True):
self._turtle.pensize(size)
if log:
self._commands.append("width%d"%size)
def pensize(self, size, log=True):
return self.width(size, log=log)
def commands(self):
return ':'.join(self._commands)
screen = Screen()
screen.setup(width=500, height=400)
screen.bgpic("grass.gif")
is_race_on = False
color_list = ["orange", "red", "blue", "gold", "violet", "pink", "cyan"]
y_positions = [-90, -60, -30, 0, 30, 60, 90]
all_turtles = []
winner = ""
for turtle_index in range(0, 7):
new_turtle = Turtle(shape="turtle")
new_turtle.penup()
new_turtle.color(color_list[turtle_index])
new_turtle.goto(x=-230, y=y_positions[turtle_index])
all_turtles.append(new_turtle)
user_bet = screen.textinput(title="Make your bet", prompt="Who is going to win the Race? Choose a color - ")
if user_bet:
is_race_on = True
while is_race_on:
for turtle in all_turtles:
new_distance = random.randint(0, 10)
turtle.forward(new_distance)
if turtle.xcor() > 230:
winner = turtle.color()
games. Bear in mind that the simplicity of the turtle library hurts its performance
considerabily. Therefore is is seen as a stepping stone to other more powerful low-level
libraries such as openGl, Vulkan and DirectX12
-------------------------------------- Jonas -------------------- """
from turtle import Turtle, Screen
# --- Create objects---
screen = Screen()
tut1 = Turtle()
tut2 = Turtle()
# --- INIT turtles ---
tut1.speed(1)
tut1.penup()
tut1.shape("circle")
tut1.shapesize(5)
tut1.color("red")
tut2.speed(1)
tut2.penup()
tut2.shape("square")
tut2.shapesize(5)
tut2.color("blue")
# --- ACTION ---
tut1.forward(100)
tut2.backward(100)
screen.mainloop()
from turtle import Turtle, Screen
import random
tim = Turtle()
tim.shape('turtle')
colors = [
'CornflowerBlue', "DarkOrchid", "IndianRed", "DeepSkyBlue",
"LightSeaGreen", "wheat", "SlateGray", "SeaGreen"
]
# tim the turtle will be drawing shapes
def draw_shape(num_sides):
angle = 360 / num_sides
for _ in range(num_sides):
tim.forward(100)
tim.right(angle)
for shape_side_n in range(3, 11):
tim.color(random.choice(colors))
draw_shape(shape_side_n)
screen = Screen()
screen.exitonclick()
class MazeGraphics(object):
def __init__(self, config):
self.width = config.getValueAsInt("maze", "maze_size")
self.height = config.getValueAsInt("maze", "maze_size")
self.bg_color = config.getValue("maze", "bg_color")
self.line_color = config.getValue("maze", "line_color")
self.line_centroid_color = config.getValue("maze", "line_centroid_color")
self.forward_centroid_color = config.getValue("maze", "forward_centroid_color")
self.reverse_centroid_color = config.getValue("maze", "reverse_centroid_color")
self.path_color = config.getValue("maze", "path_color")
self.screen = Screen()
self.setupTurtle(self.width, self.height)
def setupTurtle(self, width, height):
self.screen.tracer(False)
self.screen.screensize(width, height)
# some basic turtle settings
self.screen.setworldcoordinates(-1, -1, width + 1, height + 1)
self.screen.title("Random Turtle Maze")
self.screen.bgcolor(self.bg_color)
self.screen.delay(None)
self.designer = Turtle(visible=False)
def drawGrid(self):
for i in xrange(0, self.width + 1):
self.drawXLines(i, self.width, self.line_color)
for i in xrange(0, self.height + 1):
self.drawYLines(i, self.width, self.line_color)
self.screen.update()
def drawXLines(self, position, width, color):
self.drawLines(position, 0, width, color, 90)
def drawYLines(self, position, width, color):
self.drawLines(0, position, width, color, 0)
def drawLines(self, xPosition, yPosition, width, color, heading):
self.designer.up()
self.designer.setposition(xPosition, yPosition)
self.designer.color(color)
self.designer.down()
self.designer.setheading(heading)
self.designer.forward(width)
self.designer.up()
def drawCentroid(self, cell, color):
"""
Draw a centroid for animation purposes but then overwrite it.
"""
self.designer.setposition(cell.centroid)
self.designer.dot(5, color)
self.screen.update()
self.designer.dot(5, self.bg_color)
def removeWall(self, posx, posy, heading, color):
"""
We tear down walls to build the maze
"""
self.designer.up()
self.designer.setposition(posx, posy)
self.designer.down()
self.designer.color(color)
self.designer.setheading(heading)
self.designer.forward(1)
self.designer.up()
self.screen.update()
def drawPath(self, cell1, cell2):
"""
This draws a line for the solution as it's worked out.
"""
self.designer.setposition(cell1.centroid)
self.designer.color(self.path_color)
direction = self.getDirection(cell1, cell2)
if direction == "N":
self.designer.setheading(90)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "S":
self.designer.setheading(270)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "W":
self.designer.setheading(0)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "E":
self.designer.setheading(0)
self.designer.down()
self.designer.backward(1)
self.designer.up()
self.drawCentroid(cell2, self.line_centroid_color)
self.screen.update()
def getDirection(self, currCell, nextCell):
direction = None
if nextCell.x < currCell.x:
direction = "E"
elif nextCell.x > currCell.x:
direction = "W"
elif nextCell.y < currCell.y:
direction = "S"
elif nextCell.y > currCell.y:
direction = "N"
return direction
from turtle import Turtle
p = Turtle()
p.speed(3)
p.pensize(5)
p.color("black", 'yellow')
p.begin_fill()
for i in range(5):
p.forward(200)
p.right(144)
p.end_fill()
screenMinX = -screen.window_width() / 2
screenMinY = -screen.window_height() / 2
screenMaxX = screen.window_width() / 2
screenMaxY = screen.window_height() / 2
screen.setworldcoordinates(screenMinX, screenMinY, screenMaxX, screenMaxY)
screen.bgcolor("black")
offscreen_x = screenMinX - 100
t = Turtle()
t.penup()
t.ht()
t.speed(0)
t.goto(0, screenMaxY - 20)
t.color("grey")
t.write("Asteroids!!", align="center", font=("Arial", 20))
t.goto(0, screenMaxY - 33)
t.write("Use the arrow keys to move, 'x' to fire, 'q' to quit", align="center")
t.goto(0, 0)
t.color("red")
class Bullet(Turtle):
def __init__(self, screen, x, y, heading):
super().__init__()
self.speed(0)
self.penup()
self.goto(x, y)
self.seth(heading)
self.screen = screen
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Nov 13 20:52:19 2017
@author: xie
"""
from turtle import Turtle
p = Turtle()
p.speed(1)
p.pensize(5)
p.color('black', 'yellow')
p.begin_fill()
for i in range(5):
p.forward(200)
p.right(144)
p.end_fill()
from turtle import Turtle
from random import random,choice
usr = Turtle()
usr.pensize(5)
usr.speed(0)
colors = [
'red',
'orange',
'yellow',
'green',
'blue',
'violet',
'gold',
'black',
]
def random_color():
return (random(),random(),random())
while True:
for count in range(4):
usr.forward(100)
usr.right(90)
usr.right(5)
usr.color(random_color())
bot.color("green");
bot.speed("slowest");
#bot.setpos(x, y)
#bot.st()
bot.circle(50);
bot.clear()
window = Screen();
window.bgcolor("yellow");
#draw_triangle(3, 100, 100)
#draw_square(4, 200, 200)
#draw_circle(300, 300)
# 1. don't show trutle shape.
# 2. we need to draw multiple squres (360/10 = 36 squares)
# 3. each squre we should start with different angle (10 degrees).
# 4. for each square, createa turtle and call square function.
bot = Turtle()
#bot.ht()
bot.color("blue", "green");
bot.speed("fast");
bot.begin_fill()
for i in range(0, 36):
print (" square " + str(i * 10))
draw_triangle(bot, 10)
bot.end_fill()
window.exitonclick()
def draw(self, t: Turtle):
t.speed('fastest')
t.color(self.color)
t.pensize(2)
self.jump_to(t, 0, 0)
# Turtle Docs: https://docs.python.org/2.7/library/turtle.html
from turtle import Turtle, Screen
# Create two objects: a Turtle with the name cursor and a Screen called window
cursor = Turtle()
window = Screen()
# Set the window background color to black
window.bgcolor("black")
# Make the cursor ink white, the width of the pen 3, the shape a turtle, and
# move at moderate speed
cursor.color("white")
cursor.width(3)
cursor.shape("turtle") # or "circle", "classic", etc.
cursor.speed(5) # 1 - 10
# Draw a square of side length 100 starting from the home position
cursor.home()
for i in range(4):
print cursor.position()
cursor.forward(100)
cursor.right(90)
print cursor.position()
# Move the turtle to (0, 100) without drawing anything,
# then draw a pentagon
cursor.penup()
cursor.sety(100)
print cursor.position()
def draw_in_cycle(drawer:turtle.Turtle, angle, side):
drawer.color('green')
while True:
drawer.left(angle)
drawer.forward(side)
class Drawing():
def __init__(self):
"""
This drawing class is for practicing drawing simple or even geometrical
pictures with turtle module.
Let's apply this method with easy examples.
gb = turtle.Turtle() ; gb.rigth, left, forward, backward, circle, shape,
shapesize, penup, pendown, home, clear
You can get a lot of detail information by googling 'python turtle'.
"""
self.gb = Turtle()
self.gb.shape('turtle')
self.gb.speed(6)
#self.screen = self.gb.getscreen()
#w = 150
#self.screen.setworldcoordinates(-w,-w,w,w)
print 'A cute turtle is ready to draw!'
def swirl(self,shape='turtle',speed=0):
self.gb.shape(shape)
self.gb.speed(speed)
self.gb.color('black')
for i in range(500):
self.gb.forward(i)
self.gb.right(98)
def color_swirl(self,shape='turtle',speed=0):
self.gb.shape(shape)
self.gb.speed(speed)
for i in range(500):
color = colorsys.hsv_to_rgb(i/1000.0,1.0,1.0)
self.gb.color(color)
self.gb.forward(i)
self.gb.right(98)
def zigzag(self,shape='turtle',speed=0):
self.gb.shape(shape)
self.gb.speed(speed)
for i in range(180):
self.gb.forward(100)
self.gb.right(30)
self.gb.forward(20)
self.gb.left(60)
self.gb.forward(50)
self.gb.right(30)
self.gb.penup()
self.gb.setposition(0,0)
self.gb.pendown()
self.gb.right(2)
def square(self,shape='turtle',speed=0):
self.gb.shape(shape)
self.gb.speed(speed)
for i in range(400):
self.gb.forward(i)
self.gb.left(90.5)
def gohome(self):
wiggle = [30,30,30,30]
self.gb.shape('turtle')
self.gb.speed(6)
self.gb.clear()
self.gb.penup()
for tick in wiggle:
self.gb.right(tick)
self.gb.left(tick)
self.gb.home()
self.gb.clear()
self.gb.pendown()
self.gb.color('black')
class KeysMouseEvents:
def __init__(self):
super().__init__()
self.reinit()
def reinit(self):
self.T=Turtle()
self.screen=self.T.getscreen()
self.screen.onclick(self.drawcir)
self.screen.onkey(self.clear,"c")
self.T.pensize(5)
self.screen.listen()
self.count=0
self.firstx=0
self.firsty=0
self.secondx=0
self.secondy=0
self.T.hideturtle()
self.T.up()
def clear(self):
self.T.screen.clear()
self.reinit()
def drawcir(self,x,y):
self.count = (self.count + 1)
if self.count == 1:
self.T.color("black")
self.firstx=x
self.firsty=y
self.T.goto(x,y)
self.T.down()
self.T.dot()
self.T.up()
return
if self.count == 2:
self.secondx=x
self.secondy=y
X = self.secondx - self.firstx
Y = self.secondy - self.firsty
d = X * X + Y * Y
self.T.color("black")
radious = math.sqrt (d);
self.T.goto(self.firstx, self.firsty-radious)
self.T.down()
self.T.circle(radious)
self.T.up()
c = random.randint(1, 4)
if c == 1:
self.T.color("red")
if c == 2:
self.T.color("green")
if c == 3:
self.T.color("blue")
if c == 4:
self.T.color("yellow")
self.T.begin_fill()
radious=radious-4
self.T.goto(self.firstx, self.firsty-radious)
self.T.down()
self.T.circle(radious)
self.T.end_fill()
self.T.up()
self.T.color("black")
self.T.goto(self.firstx,self.firsty)
self.T.down()
self.T.dot()
self.T.up()
self.count=0
def main(self):
mainloop()
from turtle import Turtle, Screen
def snowflake(t, iterations, size):
if iterations == 0: # Base Case
t.forward(size)
else:
pass
atuin = Turtle()
window = Screen()
atuin.color("#FFFFFF")
window.bgcolor("#0191C8")
atuin.penup()
atuin.backward(50)
atuin.pendown()
atuin.pensize(4)
num_sides = 3
iterations = 0
for i in range(num_sides):
snowflake(atuin, iterations, 100)
atuin.right(360 / num_sides)
window.exitonclick()
screenMinX = -screen.window_width() / 2
screenMinY = -screen.window_height() / 2
screenMaxX = screen.window_width() / 2
screenMaxY = screen.window_height() / 2
screen.setworldcoordinates(screenMinX, screenMinY, screenMaxX, screenMaxY)
screen.bgcolor("black")
offscreen_x = screenMinX - 100
t = Turtle()
t.penup()
t.ht()
t.speed(0)
t.goto(0, screenMaxY - 20)
t.color('grey')
t.write("Turtles in Space!!", align="center", font=("Arial", 20))
t.goto(0, screenMaxY - 33)
t.write("Use the arrow keys to move, 'x' to fire, 'q' to quit", align="center")
t.goto(0, 0)
t.color("red")
class Bullet(Turtle):
def __init__(self, screen, x, y, heading):
super().__init__()
self.speed(0)
self.penup()
self.goto(x, y)
self.seth(heading)
self.screen = screen
from random import random
from turtle import Turtle
def color_random():
return (random(),random(),random())
llama = Turtle()
while True:
llama.color(color_random())
llama.pensize(10)
llama.forward(100)
llama.right(120)
llama.right(10)
def add_segment(self, position):
new_seg = Turtle(shape="square")
new_seg.color("white")
new_seg.penup()
new_seg.goto(position)
self.segments.append(new_seg)
def main():
t = Turtle()
my_win = Screen()
t.width(12)
t.speed(10)
t.left(90)
t.up()
t.backward(100)
t.down()
t.color("brown")
tree(75, t)
my_win.exitonclick()
