def path(individual , dat , fitness , len_dat): # 適応度の最大値が何番目かを出力 print("適応度の最大の番地 -> " + str(fitness.index(max(fitness)))) nowKame = dat.ix[individual[fitness.index(max(fitness))]] # 初期設定 kame = turtle.Turtle() kame = turtle.shape('turtle') turtle.screensize(500,1000) for i in range(len(nowKame)): if i == 0: kame = turtle.up() kame = turtle.goto(nowKame.ix[i , 0] * 2 , nowKame.ix[i , 1] * 2) kame = turtle.down() kame = turtle.write("Start") else: kame = turtle.setpos(nowKame.ix[i , 0] * 2 , nowKame.ix[i , 1] * 2) kame = turtle.write(i + 1) print("exitと入力すると終了します") while True: line = input() if line == "exit": break
def main(): board_ac=[10,2,3,4,5,6,7,8,9] turtle.screensize(300,300) turtle.hideturtle() go_to(0,0,0) board() #players() win=0 n_jogada=0 player1=input('Player 1:\t') player2=input('Player 2:\t') while win!=1: n_jogada += 1 if check(board_ac) == True: if (-1)**n_jogada == -1: win=1 print(player2, 'Ganhou!') else: win=1 print(player1, 'Ganhou!') else: player_turn(n_jogada, board_ac) turtle.exitonclick()
def __init__(self, length, width, roomba_step, obstacles=None): ''' ###initialization ''' self.obstacles = obstacles self.orient = 0 self.length = length #assume length in m self.width = width #assume width in m self.roomba_step = roomba_step#assume in m self.multiply_factor = 50 #screenstep = multiply_factor * length/width self.step_l = self.length*self.multiply_factor self.step_w = self.width*self.multiply_factor self.roomba_l = self.roomba_step*self.multiply_factor self.t = turtle.Turtle() self.t.shape("classic") turtle.setup(self.step_l+100,self.step_w+100) turtle.screensize(self.step_l+10, self.step_w+10) #turtle.bgcolor("orange") self.t.penup() self.t.bk(self.step_l/2) # backward() self.t.lt(90) # left() self.t.fd(self.step_w/2) # forward() self.t.rt(90) # right() self.draw_boundary(self.step_l, self.step_w, self.roomba_l, self.t) ###set pen width self.t.pendown() self.t.pencolor("green") self.t.pensize(self.roomba_l-1) self.t.fd(self.roomba_l)
def viewer(dna): '''Display ORFs and GC content for dna.''' dna = dna.upper() # make everything upper case, just in case t = turtle.Turtle() turtle.setup(1440, 240) # make a long, thin window turtle.screensize(len(dna) * 6, 200) # make the canvas big enough to hold the sequence # scale coordinate system so one character fits at each point setworldcoordinates(turtle.getscreen(), 0, 0, len(dna), 6) turtle.hideturtle() t.speed(0) t.tracer(100) t.hideturtle() # Draw the sequence across the bottom of the window. t.up() for i in range(len(dna)): t.goto(i, 0) t.write(dna[i],font=("Helvetica",8,"normal")) # Draw bars for ORFs in forward reading frames 0, 1, 2. # Draw the bar for reading frame i at y = i + 1. t.width(5) # width of the pen for each bar for i in range(3): orf(dna, i, t) t.width(1) # reset the pen width gcFreq(dna, 20, t) # plot GC content over windows of size 20 turtle.exitonclick()
def __init__(self): # Janela sobre self.janSobre = None # Cor de fundo self.corFundo = "gray" turtle.screensize(1000, 700, self.corFundo) turtle.setup(width=1000, height=700) turtle.title("cidadeBela - Janela de desenho") turtle.speed(0) turtle.tracer(4) # Definindo variáveis globais self._tamPadrao = "" # Listas de prédios self.predios = ['Casa', 'Hotel'] self.prediosProc = [ 'hotel', 'hotelInv', 'casa', 'casaInv' ] # Sorteando elementos self.sorteioPredios = [["casa", 1], ["hotel", 1]] self.sorteioPrediosInv = [["casaInv", 1], ["hotelInv", 1]] # Cores dos prédios self.coresHotel = ["076080190", "255255255", "167064057", "153204255", "000090245", "201232098", "255058123", "010056150", "130255255", "255255000", "255000000", "255127042", "000255000", "255170255", "000255170", "212000255", "170255127", "127212255", "255127127", "255212085", "212212255", "255255127", "222202144" ] self.coresCasa = ['209187103', '115155225', '130047006', '255137111', '203229057', '017130100', '025195159', '204057065', '194082255', '092221159', '167045055', '238243030', '069241248', '000156228', '159094040', '048033253', '040209239', '138164253', '190042177', '000122159', '255255255', '253208201', '245228133'] self.coresLoja = ['255255255', '253208201', '245228133' ] # Janelas dos prédios self.janelasHotel = janelas.janelasHotel self.janelasCasa = janelas.janelasCasa self.janelasLoja = janelas.janelasLoja self.janelasTodas = janelas.janelasTodas # Tetos dos prédios self.tetosHotel = tetos.tetosHotel self.tetosCasa = tetos.tetosCasa self.tetosLoja = tetos.tetosLoja self.tetosTodas = tetos.tetosTodas # Portas dos prédios self.portasHotel = portas.portasHotel self.portasCasa = portas.portasCasa self.portasLoja = portas.portasLoja self.portasTodas = portas.portasTodas
def __init__(self): turtle.title('Phogo - CRM UAM') turtle.mode('logo') turtle.penup() #turtle.setx(turtle.screensize()[0] // 8) turtle.screensize(4000, 4000)
def franklinBegin(): turtle.screensize(3000, 3000) turtle.clearscreen() turtle.bgcolor('black') franklin = turtle.Turtle(visible = False) franklin.color('green', 'green') franklin.speed(0) return franklin
def drawcurve(points): myTurtle = turtle.Turtle(shape="turtle") turtle.screensize(500,500) turtle.setworldcoordinates(400,400,500,500) myTurtle.penup() y = points[0] myTurtle.setposition(y[0], y[1]) myTurtle.pendown() for x in points: myTurtle.setposition(x[0], x[1]) turtle.getscreen()._root.mainloop()
def initialize(color='brown', smallest=1.0): '''Prepare to draw a von Koch Snowflake.''' turtle.setup(400, 300) turtle.screensize(350, 250) turtle.clear() turtle.up() turtle.goto(-100.0, 55.0) turtle.setheading(0) turtle.color(color) turtle.down() global smallestLineLength smallestLineLength = smallest
def koch(l,s,t): #level and size turtle.screensize(2000,2000) t.speed(0) t.up() t.setpos(-s/2.,-s/3.*math.sin(math.pi/3)) t.down() t.ht() turtle.tracer(0,0) for i in range(3): kochLine(l,s,t) t.left(120) turtle.update()
def main(): turtle.screensize(1000) for i in range(1,5): turtle.speed = 2*i turtle.penup() turtle.goto(-340,-200) #move to left hand side turtle.pendown() koch(i,i*250) #draw a koch snowflake of ordwer i time.sleep(1) turtle.bye() #close current window
def DrawSierpinskiTriangle(level, ss=400): # typical values turn = 0 # initial turn (0 to start horizontally) angle=60.0 # in degrees # Initialize the turtle turtle.hideturtle() turtle.screensize(ss,ss) turtle.penup() turtle.degrees() # The starting point on the canvas fwd0 = float(ss) point=array([-fwd0/2.0, -fwd0/2.0]) # Setting up the Lindenmayer system # Assuming that the triangle will be drawn in the following way: # 1.) Start at a point # 2.) Draw a straight line - the horizontal line (H) # 3.) Bend twice by 60 degrees to the left (--) # 4.) Draw a straight line - the slanted line (X) # 5.) Bend twice by 60 degrees to the left (--) # 6.) Draw a straight line - another slanted line (X) # This produces the triangle in the first level. (so the axiom to begin with is H--X--X) # 7.) For the next level replace each horizontal line using # X->XX # H -> H--X++H++X--H # The lengths will be halved. decode = {'-':Left, '+':Right, 'X':Forward, 'H':Forward} axiom = 'H--X--X' # Start the drawing turtle.goto(point[0], point[1]) turtle.pendown() turtle.hideturtle() turt=turtle.getpen() startposition=turt.clone() # Get the triangle in the Lindenmayer system fwd = fwd0/(2.0**level) path = axiom for i in range(0,level): path=path.replace('X','XX') path=path.replace('H','H--X++H++X--H') # Draw it. for i in path: [turn, point, fwd, angle, turt]=decode[i](turn, point, fwd, angle, turt)
def main(): t = turtle.Turtle() myWin = turtle.Screen() getscreen().tracer(5, 0) turtle.screensize(bg='wheat') t.left(90) t.up() t.backward(150) t.down() t.color('sienna') tree(60, t) petal(100, t) myWin.exitonclick()
def setupboundingbox(): turtle.reset() turtle.setup(1100, 1100) turtle.screensize(canvwidth=1100, canvheight=1100) turtle.up() turtle.goto(-500, -500) turtle.setheading(90) turtle.down() turtle.forward(1000) turtle.right(90) turtle.forward(1000) turtle.right(90) turtle.forward(1000) turtle.right(90) turtle.forward(1000)
def drawCloud(words, num = 20): """ Draws a wordcloud with 20 random words, sized by frequency found in the WORDS dictionary. """ t.reset() t.up() t.hideturtle() topCounts = sorted([words[word] for word in list(words.keys()) if len(word) > 3]) largest = topCounts[0] normalized_counts = {} for item in list(words.keys()): if len(item) > 3: newSize = int(float(words[item]) / largest * 24) normalized_counts[item] = newSize size = t.screensize() width_dim = (int(-1 * size[0] / 1.5), int(size[0] / 2)) height_dim = (int(-1 * size[1] / 1.5), int(size[1] / 1.5)) for item in random.sample(list(normalized_counts.keys()), num): t.goto(random.randint(*width_dim), random.randint(*height_dim)) t.color(random.choice(COLORS)) try: t.write(item, font = ("Arial", int(normalized_counts[item]), "normal")) except: try: t.write(str(item, errors = 'ignore'), font = ("Arial", int(normalized_counts[item]), "normal")) except: pass
def start(width, height, x, y, _delay, _name): turtle.setup(width+45, height+45) turtle.screensize(width+15, height+15) turtle.up() turtle.goto(x, y) turtle.pendown() turtle.shape('turtle') global canvas canvas = turtle.getscreen().getcanvas() canvas.after(_delay, dump) global delay delay = _delay global name name = os.path.splitext(os.path.basename(_name))[0]
def drawImage(paths): myTurtle = turtle.Turtle(shape="turtle") turtle.screensize(2000,2000) myTurtle.pendown() myTurtle.penup() myTurtle.setposition(0, 0) y = 0 for path in paths: myTurtle.penup() temp = path[0] myTurtle.setposition(temp[0], temp[1]) myTurtle.pendown() y = 1 for x in paths: for y in x: myTurtle.setposition(y[0], y[1]) myTurtle.penup() turtle.getscreen()._root.mainloop()
def main(wide_dis,height_dis,path): turtle.screensize(1000,1700) tu = turtle.Turtle() tu.hideturtle() tu.speed(0) adj_list_edge=get_graph(path) adj_list=get_adj_list(adj_list_edge) get_weight(adj_list) list=sorted(adj_list,key=lambda v:v.weight) c=create_context(list) height= c.max_height for k in c.data: i=1 wide=len(c.data[k]) for v in c.data[k]: v.heart=(pos(i,wide,wide_dis),pos(height-k-1,height,height_dis)) i+=1 pair={} for v in list: s=None if v.type=="exclude": s=draw.Diamond(tu,v.name) pair[v]=s else: s=draw.Square(tu,v.name) pair[v]=s start=s.heart2start(v.heart) s.move(start[0],start[1]) s.draw() for v in adj_list_edge: list=adj_list_edge[v] for iter in list: s=pair[v] e=pair[iter[0]] dis=s.near_shape(e) l = draw.LineWithArrow(tu,iter[1]) l.draw(dis[0],dis[1]) l.move() mainloop()
def setScreen(matrix): '''sets the screensize''' dim = (DOTSIZE+1)*len(matrix)+BORDER screensize(dim,dim)
else: tmp = getDirData(int(qactual[1])) if int(qactual[3]) >= 40000: data = getDirData(int(qactual[3])) else: data = int(qactual[3]) addDirData(data, tmp) memoria.freeLocalMemory() ipscope = memoria.getIP() if ipscope[1] != "*work*": memoria.awakeLocalMemory() ip = ipscope[0] current_scope = ipscope[1] if (turtle.pos()[0] < -turtle.screensize()[0]): turtle.hideturtle() turtle.penup() turtle.goto(turtle.screensize()[0], turtle.pos()[1]) turtle.showturtle() elif (turtle.pos()[0] > turtle.screensize()[0]): turtle.hideturtle() turtle.penup() turtle.goto(-turtle.screensize()[0], turtle.pos()[1]) turtle.showturtle() elif (turtle.pos()[1] > turtle.screensize()[1]): turtle.hideturtle() turtle.penup() turtle.goto(turtle.pos()[0], -turtle.screensize()[1]) turtle.showturtle() elif (turtle.pos()[1] < -turtle.screensize()[1]):
import turtle as tl def star(): tl.color('red', 'yellow') tl.begin_fill() while True: tl.forward(200) tl.left(170) if abs(tl.pos()) < 1: break tl.end_fill() tl.done() def yes_it_is(x, y): tl.goto(x, y) tl.write("yes it is!", align='center', font=('Helvetica', 11)) tl.ht() tl.bgcolor('lightsteelblue') tl.pencolor('orange') tl.screensize(300, 300) tl.write("is this a game?", align='center', font=('Helvetica', 36)) star() tl.mainloop()
max_temperature = temperatures_list[0] min_temperature = temperatures_list[1] if max_temperature < min_temperature: max_temperature, min_temperature = min_temperature ,max_temperature for i in range(2, len(temperatures_list)): if temperatures_list[i] > max_temperature: max_temperature = temperatures_list[i] elif temperatures_list[i] < min_temperature: min_temperature = temperatures_list[i] d_temperature = max_temperature - min_temperature dy = 200 / d_temperature turtle.screensize(800,800) turtle.setworldcoordinates(0, 0, 800,800) tess = turtle.Turtle() tess.color("blue") tess.pensize(3) tess.penup() for i, temperature in enumerate(temperatures_list): x = i * 20 y = (temperature - min_temperature) * dy + 350 tess.goto(x, y) tess.pendown() turtle.done()
parser.add_argument('-n', '--num', help='set number of iterations', type=int, default=-1) args = parser.parse_args() try: # Import rule module rule = importlib.import_module(args.module) # Expand L-system num = args.num if (num < 0): num = rule.n text = rule.axiom for _ in range(num): text = iterate(text, rule.subs) # Render using turtle graphics turtle.screensize(canvwidth=2000, canvheight=2000) turtle.hideturtle() turtle.speed(0) for c in text: if c in rule.graphics: rule.graphics[c](turtle) turtle.done() except ModuleNotFoundError: print('Invalid rule module. Make sure not to include file extension.') except turtle.Terminator: pass
############ ##### ####### # ##### #### ##### ############# #### ###### ######### ####### #### ############################### ############################################################################################################################################# ############################################################# TANK WAR V 1.0 ################################################################ from turtle import bgpic from turtle import title from turtle import screensize from turtle import bgcolor import turtle as t from math import* from random import* ####################### registers shapes for turtle ############################################################################ t.speed('fastest') title('Tank-War v 1.0 ') screensize(1024,700) bgpic('bg.gif') bgcolor('black') t.ht() t.register_shape('30016.gif') t.register_shape('tankr.gif') t.register_shape('target1.gif') ##################################### Title and Screen ####################################################################################### splash=t.Turtle() splash.shape('30016.gif') ww=t.Turtle() ww.color('yellow') ww.ht() ww.up() ww.goto(-150,0) ww.down()
w1, h1 = eval(input("and r1's width and height: ")) x2, y2 = eval(input("Enter r2's center x-, y-coordinates: ")) w2, h2 = eval(input("and r2's width and height: ")) text = None if abs(x1 - x2) >= (w1 + w2) / 2 \ or abs(y1 - y2) >= (h1 + h2) / 2: text = "r2 does not overlap r1." elif abs(x1 - x2) <= (w1 - w2) / 2 \ and abs(y1 - y2) <= (h1 - h2) / 2: text = "r2 is in r1." else: text = "r2 overlaps r1." font = ("Times", 11) t.screensize(1920, 1080) t.penup() t.goto(x1 + w1 / 2, y1 + h1 / 2) t.pendown() for i in range(4): t.right(90) t.forward(h1 if i % 2 == 0 else w1) t.penup() t.goto(x2 + w2 / 2, y2 + h2 / 2) t.pendown() for i in range(4): t.right(90) t.forward(h2 if i % 2 == 0 else w2)
# Ch04 > p.115 - Example02 # This program will convert decimal int into binary digits, showing with turtles 0 & 1 import turtle as t num = 0 swidth, sheight = 1000, 300 curX, curY = 0, 0 if __name__ == "__main__": t.title("거북이로 2진수 표현하기") t.shape("turtle") t.setup(width=swidth + 50, height=sheight + 50) t.screensize(swidth, sheight) t.penup() t.left(90) num = int(input("숫자를 입력하세요 : ")) binary = bin(num) curX = swidth / 2 curY = 0 for i in range(len(binary) - 2): t.goto(curX, curY) if num & 1: t.color("red") t.turtlesize(2) else: t.color("blue") t.turtlesize(1) t.stamp() curX -= 50
t.fillcolor("#000000") t.goto(random.randint(-500, 500), random.randint(-500, 500)) f = random.randint(1, 4) #t.goto(300,0) t.pendown() t.begin_fill() t.circle(10) t.end_fill() t.fd(100) if (f == 1): t.rt(100) t.fd(10) t.rt(20) t.fd(10) t.lt(20) t.fd(10) t.lt(100) if __name__ == "__main__": screen = turtle.Screen() t = turtle.Turtle() turtle.screensize(1000, 700) turtle.tracer(1, 0) sub() for i in range(50): music() playsound.playsound("The Beatles - Yellow Submarine.mp3") screen.exitonclick()
x, y = vec2d[i] t.penup() t.goto(x, y) t.dot(5) t.pendown() if __name__ == '__main__': # initialize a cube object dirt = Cube() # the coordinates of the camera (default 0, 0, 0) # camera = Camera((0, 0, 0)) vec2d = [] vec3d = [] width, height = turtle.screensize() # the distance between the object and the viewer k2 = 70 # the distance between the object and the screen k1 = width * k2 * 3 / 8 / 50 # initial rotation angle rotX, rotY, rotZ = 0, 0, 0 while True: t.clear() # vec3d = rotation(dirt.verticies, rotX, rotY, rotZ, camera) vec3d = rotation(dirt.verticies, rotX, rotY, rotZ) vec2d = projection(vec3d, k1, k2) drawDot(vec2d)
turtle.circle(-padEcart) turtle.end_fill() turtle.up() turtle.goto(0,padEcart) turtle.down() cpt = 2 for decimale in decimales: turtle.left(90) turtle.forward(padEcart) turtle.right(90) turtle.circle(-padEcart*cpt,decimale*padAngle) cpt += 1 decimales = [3,1,4,1,5,9,2,6,5,4] padEcart = 40 turtle.screensize(2000,1500) turtle.begin_fill() turtle.color(0.4,0.4,0.4) turtle.up() turtle.goto(0,11*padEcart+10) turtle.down() turtle.circle(-(11*padEcart)-10) turtle.end_fill() drawAxe(padEcart) drawPI(padEcart,decimales) turtle.exitonclick()
import turtle as t t.shape('turtle') t.color('green', 'yellow') t.screensize(3000, 2000) t.speed(10) inp = open('input') Number = [[0,0] for i in range(12)] for i in range(1, 11, 1): num = list(inp.readline().split()) for j in range(len(num)): num[j] = num[j].split(',') Number[i] = num Number[0] = Number[10] index = [1, 4, 1, 7, 0, 7] for i in index: if (i == 1): t.up() t.lt(270) t.fd(50) t.lt(90) t.down() for angle, step in Number[i]: angle, step = float(angle), float(step) t.lt(angle) t.fd(step) else:
def draw_regular_patterns(): """Draw multiple shapes and colors using turtle library.""" import turtle turtle.screensize(800, 800) color_lst = ["#90C3D4", "#C390D4", "#D4A190", "#A1D490", "#92E85D", "#5DD7E8", "#B35DE8", "#E86E5D", "#34EAED", "#EBF779"] print ("This program draws squares of many colors.\n") num_squares = input("\nEnter the number of squares to draw: ") if not num_squares.isdigit(): print("The number must be an integer and at least 1.\nPlease try again.") sys.exit(1) elif int(num_squares) < 1: print("The number must be an integer and at least 1.\nPlease try again.") sys.exit(1) num_squares = int(num_squares) turtle_man = turtle.Turtle() x_direction, degree = (100, 90) x_cor, y_cor = (0, 0) for i in range(num_squares): turtle_man.goto(x_cor, y_cor) turtle_man.begin_fill() turtle_man.down() turtle_man.color(color_lst[random.randrange(0,10)]) for j in range(4): turtle_man.forward(x_direction) turtle_man.right(degree) turtle_man.up() # pick up pen turtle_man.end_fill() # end shape color fill x_cor += 20 y_cor += 10 #turtle.done() turtle.clear() #======================================================================# # DRAW CIRCLES #======================================================================# print ("This program draws circles of many colors.\n") num_circles = input("\nEnter the number of circles to draw: ") if not num_circles.isdigit(): print("The number must be an integer and at least 1.\nPlease try again.") sys.exit(1) elif int(num_circles) < 1: print("The number must be an integer and at least 1.\nPlease try again.") sys.exit(1) num_circles = int(num_circles) radius = 20 turtle_circa = turtle.Turtle() w_cor, z_cor = (0, 0) for i in range(num_circles): turtle_circa.goto(w_cor, z_cor) turtle_circa.begin_fill() turtle_circa.down() turtle_circa.color(color_lst[random.randrange(0,10)]) turtle_circa.circle(radius * 10) turtle_circa.up() turtle_circa.end_fill() w_cor += 50 #z_cor += 50 turtle.done()
#ground = -200 #leftpos = -500 t.pu() t.goto(leftpos, ground) t.pd() #t.fd(-500) castle(castlesize) t.fd(leftpos * -2) #kanone t.color("blue", "green") cannon() t.setheading(45) t.screensize(1600, 800) castlesize = 100 ground = -200 leftpos = -500 #t.left(70) speed = 10 play = True heading = 45 while play: #t.clear() t.pu() t.home() t.clear() t.speed(0) t.pd()
import turtle #turtle 프로그램을 가져오기 ## 변수 선언 부분 ## num, curX, curY = [0] * 3 #입력받을 숫자, 거북이의 X좌표, 거북이의 Y좌표 swidth, sheight = 1000, 300 #거북이 창 화면 크기 ## 메인 코드 부분 ## if __name__ == "__main__": #메인 코드 시작 부분 turtle.title("거북이로 2진수 숫자 표현하기") #거북이 프로그램 제목 turtle.shape("turtle") #거북이 모양 turtle.setup(width=swidth + 50, height=sheight + 50) #거북이가 이동할 수 있는 범위(1050, 350) turtle.screensize(swidth, sheight) #거북이 창 화면 크기(1000, 300) turtle.penup() #거북이 흔적없이 이동 turtle.left(90) #거북이가 90도 왼쪽으로 회전 num_01 = int(input("숫자를 입력해주세요. :")) #숫자를 입력 받는다. num_02 = int(input("숫자를 입력해주세요. :")) #숫자를 입력 받는다. num_1 = num_01 binary = bin(num_1) #입력받은 정수를 2진수로 변환하여 binary라는 변수 이름으로 선언한다. curX = swidth / 2 #초기 위치 중 X좌표를 500으로 설정 curY = 100 #초기 위치 중, Y좌표를 0으로 설정 for i in range(len(binary) - 2): #변환한 2진수의 개수만큼 반복한다. #len은 길이를 나타냄. 2진수로 변환하면서 생기는 0b로 인하여 -2를 실행. turtle.goto(curX, curY) #turtle이 (curX, curY) 좌표로 이동한다. if num_1 & 1: #[비트 연산자] num의 2진수 맨 마지막 자리가 1일 때 turtle.color("red") #거북이의 색을 빨간색으로 바꿔준다. turtle.turtlesize(2) #거북이의 크기를 2로 조정한다.
import turtle import random turtle.screensize(canvwidth=600, canvheight=600, bg=None) t = turtle.Turtle() #wn = turtle.Screen() t.home() t.speed(0) x = int(input('Line Length: ')) y = int(input('Line circle redious: ')) z = int(input('Give circle angle: ')) i = 0 J = 0 while i < 1000: t.fd(x + J) t.circle(y, z) i = i + 1 if i == 200: J = x coin = random.randrange(0, 2) if coin == 0: # heads t.left(90) else: # tails t.right(90) #print (t.position())
import turtle # 导入模块 zhufu = turtle.Turtle() # 创建Turtle对象,命名为zhufu chuangkou = turtle.Screen # 创建窗口 turtle.screensize(400, 300, "green") # 设置窗口长宽,背景色 zhufu.pencolor("green") # 设置画笔颜色 zhufu.hideturtle() # 隐藏箭头 zhufu.setpos(-150, 50) # 移动画笔至坐标 处 zhufu.pencolor("red") # 设置画笔颜色 if True: # 输入5 zhufu.pensize(15) zhufu.left(180) zhufu.forward(50) zhufu.left(90) zhufu.forward(50) zhufu.left(90) zhufu.forward(50) zhufu.right(90) zhufu.forward(50) zhufu.right(90) zhufu.forward(50) if True: # 输入2 zhufu.penup() # 抬起画笔 zhufu.setpos(-50, 50) # 移动画笔至坐标 处 zhufu.pendown() # 放下画笔 zhufu.left(180) zhufu.forward(50) zhufu.right(90) zhufu.forward(50) zhufu.right(90) zhufu.forward(50)
import turtle turtle.screensize(1500, 2000) my_turtle = turtle.Turtle() #;rectangle def star(x: int, y: int, angle: int, length: int, color: str): turtle.pu() turtle.goto(0, 0) turtle.setx(x) turtle.sety(y) turtle.pd() turtle.width(3) turtle.pencolor(color) turtle.seth(angle) turtle.fd(length) star(-200, 200, 0, 400, 'blue') star(200, 200, -144, 400, 'red') star(-124, -35, 72, 400, 'green') star(0, 345, 288, 400, 'black') star(124, -35, 144, 400, 'purple')
''' Created on 10/10/2018 @author: Susmitha Shailesh Pledge: I pledge my honor that I have abided by the Stevens Honor System. CS115 - Hw 5 ''' import turtle # Needed for graphics # Ignore 'Undefined variable from import' errors in Eclipse. '''settings for turtle''' turtle.speed(0) turtle.screensize(500, 500, "orange") turtle.pensize(200) turtle.pencolor("red") turtle.penup() turtle.goto(-150, -100) turtle.pendown() turtle.circle(10) turtle.pensize(150) turtle.pencolor("yellow") turtle.penup() turtle.goto(-150, -100) turtle.pendown() turtle.circle(10) turtle.pencolor("DarkOliveGreen") turtle.pensize(200) turtle.penup()
def main(): turtle.screensize(800, 600) turtle.title('Cartoon') cartoon = Cartoon() cartoon.start() turtle.mainloop()
''' ''' # 描述: 以给定半径画圆 参数: radius(半径); 半径为正(负),表示圆心在画笔的左边(右边)画圆 extent(弧度) (optional); steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps) turtle.circle(radius, extent=None, steps=None) 举例: circle(50) # 整圆; circle(50, steps = 3) # 三角形; circle(120, 180) # 半圆 ''' # screensize(): 参数分别为画布的宽(单位像素), 高, 背景颜色 turtle.screensize(500, 500, "white") turtle.speed(10) # 设置画笔移动速度,画笔绘制的速度范围[0,10]整数, 数字越大越快 turtle.begin_fill() # 图形准备开始填充 turtle.color('red', 'yellow') for _ in range(50): turtle.forward(200) # 向当前画笔方向移动 200 像素长度 turtle.left(170) # 逆时针移动 170° turtle.end_fill() # 填充完成 turtle.mainloop() # 启动事件循环 -调用Tkinter的mainloop函数。必须是乌龟图形程序中的最后一个语句。
import turtle as tu import random as rand import math radius = 200 tu.hideturtle() tu.tracer(0, 0) tu.speed(0) tu.screensize(500, 500) tu.penup() tu.goto(0, -radius) tu.pendown() tu.pencolor(0.8, 0.8, 0.8) tu.circle(radius) tu.pencolor(0.0, 0.0, 0.0) tu.penup() tu.goto(0, 0) tu.pendown() for i in range(4): tu.forward(radius) tu.left(90) n = 0 m = 0
vals.append(a) valsarray = np.asarray(vals) valsarray[0] = valsarray[1] + valsarray[0] valsarray = valsarray - valsarray[0] clusterlength = max(valsarray) + 50 offset = -50 #Circle radius for terminator symbol tcircrad = 15 # hide turtle and set draw speed turtle.setup(width=3000, height=1080, startx=0, starty=0) turtle.screensize(3000, 1080) turtle.hideturtle() turtle.speed(10) # line turtle.penup() turtle.right(180) turtle.forward(clusterlength * 0.5) turtle.right(180) turtle.pendown() turtle.pen(pencolor="black", pensize=4) turtle.forward(clusterlength) ## draw orfs turtle.penup()
def core(self): turtle.screensize(10000,10000) turtle.clearscreen() turtle.bgcolor("black") # select the origin in middle of the map q = self.n/2 p = self.m/2 # origin turtle.pencolor("red") turtle.fill(True) for _ in range(3): turtle.forward(5); turtle.left(120) turtle.fill(False) # init x = 0 y = 0 #while(self.map[p][q]!=1) : while(True) : self.map[p][q]+=1 # current color t = 0; if(self.map[p+1][q+1]==1) : t+=1 if(self.map[p+1][q-1]==1) : t+=1 if(self.map[p-1][q-1]==1) : t+=1 if(self.map[p-1][q+1]==1) : t+=1 if(t==0) : turtle.pencolor("white") if(t==1) : turtle.pencolor("green") if(t==2) : turtle.pencolor("blue") if(t==3) : turtle.pencolor("purple") if(t==4) : turtle.pencolor("red") # display progression with tk and turtle self.display(x) # random value x = self.randomMode(1) if(x>0 and x<=90): p += 1 q += 1 elif(x>90 and x<=180): p += 1 q -= 1 elif(x>180 and x<=270): p -= 1 q -= 1 elif(x>270 and x<=360): p -= 1 q += 1 else : print '>>>> ERROR !!!' y += 1 print '>>> ESSAI '+str(self.c) print '>>> Nombre de coups : '+str(y) (self.s).append(y) self.v += y self.c += 1 self.t -= 1
def run(): turtle.screensize(1920,1080) turtle.penup() turtle.hideturtle() point=[] # point=[[20,20],[50,10],[110,30],[110,80],[50,50],[20,70]] # point=[[-10,-10],[10,-10],[15,0],[10,10],[-10,10],[-15,0]] temp = [float(x11.get()), float(y1.get())] point.append(temp) temp = [float(x2.get()), float(y2.get())] point.append(temp) temp = [float(x3.get()), float(y3.get())] point.append(temp) temp = [float(x4.get()), float(y4.get())] point.append(temp) temp = [float(x5.get()), float(y5.get())] point.append(temp) temp = [float(x6.get()), float(y6.get())] point.append(temp) point = [[20, 20], [50, 10], [110, 30], [110, 80], [50, 50], [20, 70]] #画出原图: for i in point: turtle.goto(i[0],i[1]) turtle.pendown() turtle.goto(point[0][0],point[0][1]) #创建新边表: newEdgeTable,Y=createNewEdgeTable(point) miny,maxy=findRange(point) y=miny acativeList=[] while y<=maxy: #把新边表加进来: ynum=0 if y in Y: for i in newEdgeTable: if i.y==y: for j in i.l: acativeList.append(j) ynum=i.numy break acativeList.sort(key=AetNode.op) for j in acativeList: print((j.x,j.tx,j.my)) print("****************") #进行填色: i=0 flag=True while i<len(acativeList)-1: x1=acativeList[i].x temp=[acativeList[i+1].x,y] if temp in point and ynum>=1: ynum-=1 else: i+=1 if flag: draw(x1,y,temp[0],y) flag=not flag #更新活性边表: newacativeList=[] for i in acativeList: if i.my>y: i.x+=i.tx newacativeList.append(i) acativeList=newacativeList y+=1 turtle.mainloop()
import turtle import ctypes def screen_dimensions(): # A simple function to compute the screen's dimensions. user32 = ctypes.windll.user32 return user32.GetSystemMetrics(0), user32.GetSystemMetrics(1) screen_width, screen_height = screen_dimensions() window_width, window_height = 0.618 * screen_width, 0.8 * screen_height print(844, 614) # window = turtle.Screen turtle.setup(window_width, window_height) print(turtle.screensize()) # turtle.Screen.setup(width=screen_width, height=screen_height) def line(A, B, tad, color): x0, y0, x1, y1 = A[0], A[1], B[0], B[1] tads_position = tad.position() tads_color = tad.color() tad.color(color, color) tad.penup() tad.goto(x0, y0) tad.pendown() tad.goto(x1, y1) tad.penup() tad.goto(tads_position)
def GraficoSobreposicao(linhas_arq): tempo = calculaTempo(Distancias.obterTempos(linhas_arq)) lst = [] try: bpm = Distancias.obterBPM(linhas_arq) b = "b - BPM" z = "z - Zonas de BPM" lst.append(max(bpm)) except: b = "" z = "" try: alt = Distancias.obterAltitudes(linhas_arq) a = "a - Altitude" lst.append(max(alt)) except: a = "" rit = Distancias.obterListaRitmo(linhas_arq) tempo_sem_transladar = tempo tempo = [x / 3 for x in tempo] tempo = transladarPontos(tempo, 500 - 20) Chuu = turtle.Turtle() Chuu.penup() Chuu.hideturtle() Chuu.goto(tempo[0], -40) lst.append(max(rit)) global tela tela = turtle.Screen() turtle.screensize(max(tempo) + 50, max(lst) + 1000) op = tela.textinput( "Gráficos", "Quais gráficos deseja visualizar?\n\np - Percurso\n{}\n\nOu combine:\n{}\n{}\nr - Ritmo\n\n" .format(z, a, b)) while op != None: if op == "z": GraficoZonas(bpm, tempo, tempo_sem_transladar) if op == "p": GraficoPercurso(linhas_arq) if "b" in op or "a" in op or "r" in op: Chuu.write("Legenda:", font=("Arial", 9, "normal")) desenharEixo(lst, tempo, "", "Tempo") numerarEixoX(tempo_sem_transladar, tempo) numerarEixoY(lst, tempo) if "b" in op: Chuu.color("red") Chuu.goto(tempo[0], -80) Chuu.write("BPM", font=("Arial", 10, "normal")) Grafico(bpm, tempo, "red") if "a" in op: Chuu.color("#006400") Chuu.goto(tempo[0], -120) Chuu.write("Altitude", font=("Arial", 10, "normal")) Grafico(alt, tempo, "#006400") if "r" in op: Chuu.color("purple") Chuu.goto(tempo[0], -160) Chuu.write("Ritmo", font=("Arial", 10, "normal")) Grafico(rit, tempo, "purple") else: erro = "Opção Inválida.\n" op = tela.textinput( "Gráficos", "{}Quais gráficos deseja visualizar?\n\np - Percurso\n{}\n\nOu combine:\n{}\n{}\nr - Ritmo\n\n" .format(erro, z, a, b)) if op != None: tela.clear() tela.onkey(GraficoSobreposicao(linhas_arq), "Up") tela.listen() else: exit() turtle.done()
# Créé par Yaya, le 26/10/2020 en Python 3.7 import turtle turtle.tracer(0, 0) # accélération du tracé turtle.screensize(50, 50) # taille fenêtre graphique turtle.pu() turtle.goto(0, 0) turtle.pd() longueur = 10 angle = 120 niter = 2 #boucle motifInitial = 'F-G-G' # le motif initial creer un triangle def dessiner(tapis, longueur, angle): """ réalise une représentation graphique d'un tapis de sierpinski donnée par des chaines de caractères """ for caractere in tapis: if caractere == '+': turtle.left(angle) elif caractere == '-': turtle.right(angle) elif caractere in ['F', 'G']: turtle.forward(longueur) #dessiner('F', 50, 60) def triangle(chaine): nouvelleChaine = '' # on crée une nouvelle chaine de caractères VIDE for lettre in chaine: # on épelle la chaine de caractères donnée en paramètres if lettre == 'F': # si dans l'ancienne chaine, il y a un 'F'
# import turtle, and from turtle Turtle and Screen import turtle from turtle import Turtle, Screen # create a new instance of turtle.Pen() - t, new instance of # turtle.Screen() - screen t = turtle.Pen() screen = turtle.Screen() # set mode to logo, speed to 4, and pensize to 4 turtle.mode('logo') t.speed(5) t.pensize(4) # set screensize to that of full HD monitor, and set turlte window title turtle.screensize(canvwidth=1920, canvheight=1080) screen.title("SKETCHY SHAPES: A Shape Maker for Sketchy People") # define dict of colors to be used for pen color and fill color # you will notice if you look at the pen, fill, and bg colors, they are based # on my editor's color scheme - Gruvbox' pen_fill_colors = { 0: '#fb4934', 1: '#b8bb26', 2: '#fabd2f', 3: '#83a598', 4: '#d3869b', 5: '#8ec07c', 6: '#fe8019', 7: '#cc241d', 8: '#98971a',
# -*- coding: utf-8 -*- import turtle import turtlecollide # Importererer turtlecollide.py import wasd # importerer wasd.py # Setter størrelsen på turtle-vinduet til 500 x 500 piksler turtle.screensize(500, 500) turtlecollide.makeline(250) # Holder på antall ganger vi præver å bevege oss over linjen i = 0 def checkrightfaceplant(): #sjekker om turtle passerer forbudt linje global i step = 100 # Hvor langt turtle vil bevege seg # Om vi IKKE kolliderer med linjen if not turtlecollide.is_colliding(turtle.xcor()+step, 250): print("You may pass!") wasd.moveright() else: # Vi kolliderte med linjen print("Thou shall not pass!") # For å være litt artig, teller vi # antall ganger vi forsøker å gå over linjen. # Spillet tar slutt om vi forsøker mer enn 50 # Ganger. i += 1
def GraficoZonas(lista, tempo, tempo_sem_transladar): zonas = ["104", "114", "133", "152", "172", "190"] turtle.screensize(max(tempo) + 50, max(lista) + 50) turtle.title('Zonas de BPM') GoWon = turtle.Turtle() GoWon.color() GoWon.hideturtle() GoWon.pensize(2) GoWon.shapesize(5) GoWon.penup() GoWon.goto(-447, -50) GoWon.write("Zonas de BPM:", font=("Times New Roman", 15, "bold")) maxi = turtle.Turtle() maxi.hideturtle() maxi.color("#E43E3E") maxi.speed(100) maxi.penup() maxi.goto(tempo[0], 171) maxi.pendown() retangulo(maxi, tempo_sem_transladar, 19) maxi.penup() maxi.goto(-447, -100) maxi.write('Máxima', font=('Times New Roman', 20, "bold")) inten = turtle.Turtle() inten.hideturtle() inten.color("#EEB543") inten.speed(100) inten.penup() inten.goto(tempo[0], 152) inten.pendown() retangulo(inten, tempo_sem_transladar, 20) inten.penup() inten.goto(-447, -150) inten.write('Intensa', font=('Times New Roman', 20, "bold")) mod = turtle.Turtle() mod.hideturtle() mod.color("#4FEE43") mod.speed(100) mod.penup() mod.goto(tempo[0], 133) mod.pendown() retangulo(mod, tempo_sem_transladar, 19) mod.penup() mod.goto(-447, -200) mod.write('Moderada', font=('Times New Roman', 20, "bold")) leve = turtle.Turtle() leve.hideturtle() leve.color("#43BAEE") leve.speed(100) leve.penup() leve.goto(tempo[0], 114) leve.pendown() retangulo(leve, tempo_sem_transladar, 19) leve.penup() leve.goto(-247, -100) leve.write('Leve', font=('Times New Roman', 20, "bold")) mtL = turtle.Turtle() mtL.hideturtle() mtL.color("#535758") mtL.speed(100) mtL.penup() mtL.goto(tempo[0], 104) mtL.pendown() retangulo(mtL, tempo_sem_transladar, 10) mtL.penup() mtL.goto(-247, -150) mtL.write('Muito Leve', font=('Times New Roman', 20, "bold")) desenharEixo(lista, tempo, "BPM", "Tempo") numerarEixoYZonas(zonas, tempo, 20) numerarEixoX(tempo_sem_transladar, tempo) GoWon.goto(tempo[0], lista[0]) GoWon.pendown() for x in range(len(lista) - 1): GoWon.goto(tempo[x], lista[x]) turtle.done()
# ajout du boid boids.append(boid); speeds.append(speed) regle1.append([0, 0]) regle3.append([0, 0]) regle4.append([0, 0]) regle5.append([0, 0]) turtle.tracer(50, 1) turtle.hideturtle() # -- while True: hauteur, largeur = turtle.screensize() # calcul de la position moyenne -- regle 1 for i in range(nombre_oiseaux): centre_x, centre_y = 0, 0 for boid in boids: centre_x += boid.xcor() centre_y += boid.ycor() centre_x /= nombre_oiseaux centre_y /= nombre_oiseaux regle1[i][0] = centre_x - boids[i].xcor() regle1[i][1] = centre_y - boids[i].ycor() # calcul de la vitesse moyenne -- regle 2
import turtle import random turtle.screensize(1000, 1000, "white") #Added to make this work on smaller screens r1 = random.randint(20, 700) t1 = (800 - r1) / 2 r2 = random.randint(20, 700) t2 = (800 - r2) / 2 r3 = random.randint(20, 700) t3 = (800 - r3) / 2 r4 = random.randint(20, 700) t4 = (800 - r4) / 2 r5 = random.randint(20, 700) t5 = (800 - r5) / 2 r6 = random.randint(20, 700) t6 = (800 - r6) / 2 r7 = random.randint(20, 700) t7 = (800 - r7) / 2 r8 = random.randint(20, 700) t8 = (800 - r8) / 2 r9 = random.randint(20, 700)
def lcm(a, b): """Compute the lowest common multiple of a and b.""" return a * b / math.gcd(a, b) math.lcm = lcm # Setup Turtle ############################################################### window = Pixels(800) turtle_global.getscreen().setup(width=int(window), height=int(window), startx=None, starty=None) turtle_global.screensize(int(window) - 20, int(window) - 20, "black") turtle_global.hideturtle() turtle = Turtle() screen_size = Pixels(turtle.screen.screensize()[0]) world_size = CartesianResolution(900, 900) Distance.set_conversion_factor(screen_size, world_size.x) turtle.hideturtle() turtle.speed(0) turtle.color("white", "white") turtle.begin_fill() turtle.setpos(0, -int(TABLE_RADIUS_MM.pixels())) turtle.circle(int(TABLE_RADIUS_MM.pixels())) turtle.setpos(0, 0) turtle.end_fill() turtle.color("black", "white")
# Convert theta to radians (it will be reset to degrees before the value is increased) theta = math.radians(theta) # The polar equation for an ellipse, with adjustment for the value of angle. r = xRadius * yRadius / math.sqrt(( (yRadius * math.cos(theta - angle))**2) + ( (xRadius * math.sin(theta - angle))**2)) # Convert the polar result to cartesian format and move. x = int(r * math.cos(theta)) + xCenter y = int(r * math.sin(theta)) + yCenter steve.goto(x, y) # Initialize the screen, the pen color, and the drawing speed. turtle.screensize(1100, 625) turtle.setup(1100, 625) steve.color('black') steve.speed(0) # Move Steve to his initial location. steve.penup() steve.setpos(-490, 245) steve.pendown() steve.right(90) # Draw 13 red and white stripes. for i in range(13): steve.begin_fill() if i % 2 != 0: steve.fillcolor("#FFFFFF")
# 葵花 import turtle import time turtle.color("red") turtle.screensize(800, 600, "grey") for i in range(40): turtle.forward(200) turtle.right(110) # 右转角度 time.sleep(5)
import turtle from math import sqrt # 判断是否为素数 def is_prime(num): for i in range(2, round(sqrt(num))+1): # 能整除,非素数 if num % i == 0: return False return True # %% # 定义画布的大小和背景 turtle.setup(0.8, 0.9) turtle.screensize(100, 100, 'black') minxv = -50 # 定义起始位置 minyv = -80 maxxv = turtle.window_width()+minxv maxyv = turtle.window_height()+minyv turtle.setworldcoordinates(minxv, minyv, maxxv, maxyv) # 定义画笔的速度 turtle.speed(0) turtle.Turtle().screen.delay(0) # 绘制图形的宽度 turtle.pencolor("white") turtle.pensize(1) turtle.setheading(-90) turtle.hideturtle() # %% num = 0
i = 0 sql = "" count = 0 strdata1, strdata2, strdata3, strdata4,strdata5, strdata6, strdata7 = [], [], [], [], [], [], [] ##메인 코드 부분## con = sqlite3.connect("C:/Users/dudqh/오픈소스기초프로젝트/과제9주차") ##DB생성 cur = con.cursor() ##커서생성 #cur.execute("CREATE TABLE ttable(선분 ID int,색상R float,색상G float,색상B int,순번 int,X 좌표 int,Y 좌표 int)") turtle.title('거북이가 맘대로 다니기(DB)') turtle.shape('turtle') turtle.pensize(pSize) turtle.setup(width=swidth + 30, height=sheight + 30) turtle.screensize(swidth, sheight) while (True): # row = cur.fetchone() # col = cur.fetchall() count += 1 data1 = count data5 = count r = random.random() g = random.random() b = random.random() data2 = r data3 = g
self.turt.color('red') def reset(self): self.turt.penup() self.turt.setpos(self.pos) # 距离计算函数,计算两个人之间的距离 def dis(a, b): d = math.sqrt((a.x - b.x)**2 + (a.y - b.y)**2) return d # turtle的相关设定 turtle.setup(TOTAL_W * 2 + 200, TOTAL_H * 2, 0, 0) turtle.screensize(TOTAL_W, TOTAL_H) turtle.clearscreen() turtle.hideturtle() turtle.tracer(False) # 实验的人数参数设定 total_num = 100 infected_num = random.randint(0, total_num) # 这里以随机数确定起始感染人数 healthy_num = total_num - infected_num # 所有人的数组 persons = [] # 健康人 for i in range(healthy_num): t1 = person(0)
import turtle import mbhandler width,height = turtle.screensize() mbhandler.init() colours = [ "Red", "Green", "Blue", "Yellow", "Purple", "Cyan" ] colour = 0 turtle.pencolor(colours[colour]) speed = 0 while True: mb = mbhandler.queue.get() x = mb['accelerometer']['x'] y = mb['accelerometer']['y'] a = mb['button_a']['down'] b = mb['button_b']['down'] if abs(x) < 10: x = 0 if abs(y) < 10: y = 0
from __future__ import division, print_function # For sprites, pens, and the timer import turtle, time # Setup a Global time. __TIME = time.time() # Global answer variable __ANSWER = '' # Set a turbo mode checker __TURBO_ON = False # Create a 'Sprite' __SPRITE = turtle.Turtle() turtle.mode('logo') __SPRITE.up() __SPRTIE.speed(10) # Doesn't account for bigger snap stages. turtle.screensize(320, 480) def notImplemented(b): print(b + " has not been implemented.\n") ############################################################################### # MOTION BLOCKS # ############################################################################### """ The command blocks with dropdowns need functions: point-towards() -- at least we can probably do mouse-pointer go-to() -- [same as above] glide for -- not sure? if edge, bounce -- probably needs some more code?
def __setScreen(self): """set the screen/window depending on view static attributes.""" turtle.resizemode('noresize') self.width = self.GRID_MARGINLEFT + 2 * self.gridWidth + self.GAP_BETWEEN_GRIDS + self.GRID_MARGINRIGHT self.height = self.GRID_MARGINTOP + self.gridWidth + self.GRID_MARGINBOTTOM turtle.setup(width=self.width + 10, height=self.height + 10) turtle.screensize(self.width, self.height) turtle.bgpic("Ressources/fire_ocean.gif") turtle.reset()