Python Screen.bgcolor方法代码示例

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
def main():
    global s
    at = clock()
    s = Screen()
    s.bgcolor("black")
    s.tracer(36, 0)
    mn_eck(36, 19)
    et = clock()
    return "Laufzeit: %.3f sec" % (et - at)

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
def main():
    global s, t
    s = Screen()
    s.bgcolor("gray10")
    t = Turtle(visible=False, shape="square")
    t.pu()
    t.speed(0)
    s.tracer(False)
    ta = clock()
    recsquare(256, 0.5, colors)
    tb = clock()
    return "{0:.2f}sec.".format(tb-ta)

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
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()

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
def principal():
    janela = Screen()
    janela.setup(800,600)
    janela.title('Digimon, digitais, Digimon são campeões!')
    janela.bgcolor('white')
    carregaimagens('personagens', janela)
    carregaimagens ('digimons', janela)
    carregaimagens('digimonftowners', janela)
    carregaimagens('fundos', janela)
    cria_personagens()
    abertura(janela)
    ato2(janela)
    ato3(janela)
    ato4(janela)
    ato5(janela)
    ato6(janela)
    ato7(janela)
    ato8(janela)
    #finale(janela)
    fechamento(janela)
    debora_animacao(janela)

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
def main():
    s = Screen()
    s.bgcolor("black")
    p=Turtle()
    p.speed(0)
    p.hideturtle()
    p.pencolor("red")
    p.pensize(3)

    s.tracer(36,0)

    at = clock()
    mn_eck(p, 36, 19)
    et = clock()
    z1 = et-at

    sleep(1)

    at = clock()
    while any([t.undobufferentries() for t in s.turtles()]):
        for t in s.turtles():
            t.undo()
    et = clock()
    return "Laufzeit: {0:.3f} sec".format(z1+et-at)

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
def main():
    s = Screen()
    s.bgcolor("black")
    p=Turtle()
    p.speed(0)
    p.hideturtle()
    p.pencolor("red")
    p.pensize(3)

    s.tracer(36,0)

    at = clock()
    mn_eck(p, 36, 19)
    et = clock()
    z1 = et-at

    sleep(1)

    at = clock()
    while any(t.undobufferentries() for t in s.turtles()):
        for t in s.turtles():
            t.undo()
    et = clock()
    return "runtime: %.3f sec" % (z1+et-at)

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
from time import sleep

from turtle import Turtle, Screen
import turtle
import random
import math

screen = Screen()
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")

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
class TetrisBoard(object):
    def __init__(self, cols, rows):
        self.cols, self.rows = cols, rows
        self.screen = Screen()
        self.screen.screensize(BLOCKWIDTH*cols-50, BLOCKWIDTH*rows-50)
        self.screen.setup(BLOCKWIDTH*cols+12, BLOCKWIDTH*rows+12)
        self.screen.title("Turtle Tetris")
        self.screen.bgcolor("black")
        self.writer = Turtle()
        self.writer.ht()        
        self.label = None
        self.grid = {}
        self.screen.tracer(False)
        for row in range(rows):
            for col in range(cols):
                self.grid[(col, row)] = TetrisTurtle(col, row)
        self.screen.tracer(True)
        self.brick = TetrisBrick(self)
        self.result = 0
        self.LEVEL = 0.6
        self.keybuffer = KeyBuffer(self.screen,
                            ["Right", "Left", "Up", "Down", "space", "Escape"])
        self.reset()
        self.screen.listen()
        self.t1 = time()
        
    def reset(self):
        self.result = 0
        self.LEVEL = 0.600
        self.screen.tracer(False)
        self.writer.clear()
        if self.label:
            self.writer.clearstamp(self.label)
        for x in range(COLUMNS):
            for y in range(ROWS):
                self.grid[(x,y)].fillcolor("")
        self.screen.tracer(True)
        self.state = "NEWBRICK"
        
    def blink(self, y, n=1):
        for _ in range(n):
            for color in ("white", "black"):
                self.screen.tracer(False)
                for x in range(COLUMNS):
                    self.grid[(x,y)].pencolor(color)
                    sleep(self.LEVEL/10.0)
                self.screen.tracer(True)
            
    def display_result(self):
        tb = self
        tb.writer.color("white", "gray20")
        tb.writer.shape("square")
        tb.writer.shapesize(5, 15)
        tb.writer.goto(-4 ,0)
        self.label = tb.writer.stamp()
        tb.writer.goto(-2,3)
        tb.writer.write(str(tb.result) + " rows!",
                        align="center", font = ("Courier", 24, "bold") )
        tb.writer.goto(-2,-22)
        tb.writer.write("New game : <spacebar>",
                        align="center", font = ("Courier", 16, "bold") )
        tb.writer.goto(-2,-42)
        tb.writer.write("Quit : <escape>",
                        align="center", font = ("Courier", 16, "bold") )
        
    def getcolor(self, col, row):
        return self.grid[(col, row)].fillcolor()
    def setcolor(self, col, row, color):
        return self.grid[(col, row)].fillcolor(color)
    def rowfree(self, row):
        return not any([self.getcolor(col, row) for col in range(COLUMNS)])
    def rowfull(self, row):
        return all([self.getcolor(col, row) for col in range(COLUMNS)])

    def cleanup(self, shp):
        try:
            ymax = max([y for (x,y) in shp])
        except ValueError:
            self.state = "FINIS"
            return
        currenty = ymax
        while currenty > 0:
            if self.rowfull(currenty):
                self.blink(currenty, 2)
                self.result += 1
                if self.result == 8:
                    self.LEVEL = 0.4
                elif self.result == 20:
                    self.LEVEL = 0.25
                y = currenty
                while True:
                    self.screen.tracer(False)
                    for c in range(COLUMNS):
                        self.setcolor(c, y, self.getcolor(c, y-1))
                    self.screen.tracer(True)
                    if self.rowfree(y):
                        break
                    else:
                        y -= 1
            else:
#.........这里部分代码省略.........

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
#!/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.

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
        sides =  sides - 1
    #bot.clear()

def draw_circle(bot, x, y):
    #bot = turtle.Turtle();
    #bot.ht()
    bot.shape("circle");
    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()

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
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()

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
# 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()

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
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:
#.........这里部分代码省略.........

# 需要导入模块: from turtle import Screen [as 别名]
# 或者: from turtle.Screen import bgcolor [as 别名]
__author__ = 'dmytrol'
from turtle import Screen, Turtle
import math
import random

screen = Screen()
screen.bgcolor(0.9, 0.9, 0.5)

jack = Turtle()
jack.shape("turtle")


def draw_triangle(k):
    jack.color(random.random(), random.random(), random.random())
    h = math.sqrt(k * k + k * k)
    jack.begin_fill()
    jack.right(45)
    jack.forward(h)
    jack.right(135)
    jack.forward(k * 2)
    jack.right(135)
    jack.forward(h)
    jack.penup()
    jack.goto(0, 0)
    jack.right(45)
    jack.end_fill()
    screen.listen()


def draw_pine_tree():
    d = int(screen.textinput("Attention, please!",