¿Por qué programar con Python?

Te faltó lo básico, un videotutorial de como instalar y ejecutar desde el comienzo python. Qué carpeta abrir, en qué ruta, desde donde abrir el archivo .py.
He estado siguiendo los videos de Platzi y ninguno explica desde cero la programación.
Nunca explicaste que Turtle esta integrado en Python, se supone que este curso es de paga y tener que recurrir a fuentes externas gratuitas le quita el gusto a pagar por aprender aquí.
Por favor explica para Windows tambien de como ejecutar Python desde cero y paso a paso, soy principiante en programación.
Saludos.

Funciones principales en Turtle Graphics

Las funciones principales para animar nuestro objeto son las siguientes:

forward(distance): Avanzar una determinada cantidad de píxeles.
backward(distance): Retroceder una determinada cantidad de píxeles.
left(angle): Girar hacia la izquierda un determinado ángulo.
right(angle): Girar hacia la derecha un determinado ángulo.

Por otro lado, puede que en ocasiones queramos desplazarnos de un punto a otro sin dejar rastro. Para ello utilizaremos las siguientes funciones:

home(distance): Desplazarse al origen de coordenadas.
goto((x, y)): Desplazarse a una coordenada en concreto.
pendown(): Subir el lápiz para no mostrar el rastro.
penup(): Bajar el lápiz para mostrar el rastro.

Por último, puede que queramos cambiar el color o tamaño del lápiz. En ese caso utilizaremos las siguientes funciones gráficas:

shape(‘turtle’): Cambia al objeto tortuga.
pencolor(color): Cambiar al color especificado.
pensize(dimension): Tamaño de la punta del lápiz.

Esta figura me pareció muy interesante, y fue compartida en el curso anterior:

import turtle

window = turtle.Screen()

colors=['red','purple','blue','green','yellow','orange']

t = turtle.Pen()
t.speed(0)
for x in range(360):
    t.pencolor(colors[x%6])
    t.width(x/100+1)
    t.forward(x)
    t.left(59)

turtle.mainloop()

Hice un pequeño panel gráfico para controlar la tortuga.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import turtle
import tkinter as ttk
from tkinter import *
from tkinter.colorchooser import *

window = turtle.Screen()
tortuga = turtle.Turtle()
tortuga.pensize(3)

def going_home():
	tortuga.penup()
	tortuga.home()
	tortuga.pendown()

def turning_left():
	tortuga.left(30)

def turning_right():
	tortuga.right(30)

def drawing():
	tortuga.forward(30)

def pen_up():
	tortuga.penup()

def pen_pendown():
	tortuga.pendown()

def geting_color():
	tortuga.pencolor(askcolor()[1])

root = Tk()
root.title('Turtle Control Panel')

go_home_button = ttk.Button(root, text="⌂", font=('',18), command=going_home).grid(column = 0, row= 0)

turn_left_button = ttk.Button(root, text="↺", font=('',18), command=turning_left).grid(column = 1, row= 0)

turn_right_button = ttk.Button(root, text="↻", font=('',18), command=turning_right)	.grid(column = 2, row= 0)

draw_button = ttk.Button(root, text="→", font=('',18), command=drawing)	.grid(column = 3, row= 0)

pen_up_button = ttk.Button(root, text="○", font=('',18), command=pen_up).grid(column = 4, row= 0)

pen_pendown_button = ttk.Button(root, text="●", font=('',18), command=pen_pendown).grid(column = 5, row= 0)

color_button = ttk.Button(root, text="☺", font=('',18), command=geting_color).grid(column = 6, row= 0)

window.mainloop()```

La extraña figura de freddy

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()

window.screensize(400, 400 , "white")

tortuga.pensize(2)

tortuga.color("red")

x = 20
y = 400
cambio = 20

for x in range(x,400 + cambio,cambio):
    tortuga.goto(x, 0)
    tortuga.goto(0, y)
    y = y - cambio
    tortuga.goto(0, y)


tortuga.color("black")
tortuga.forward(400)
tortuga.left(90)
tortuga.forward(400)
tortuga.left(90)
tortuga.forward(400)
tortuga.left(90)
tortuga.forward(400)

turtle.done()
window.mainloop()

Excelente, les regalo este Platzi

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()
tortuga.pensize(30)
tortuga.pencolor('#94cc3c')

tortuga.left(45)
tortuga.forward(80)

tortuga.left(90)
tortuga.forward(100)

tortuga.left(90)
tortuga.forward(140)

tortuga.left(90)
tortuga.forward(130)

tortuga.left(90)
tortuga.forward(40)

window.mainloop()```

Tarde un ratico haciéndolo, pero siento que es lo mas productivo que he hecho en mi vida.

SI IMPORTAN TURTLE NUNCA NOMBREN UN ARCHIVO TURTLE, les va a generar un error constante.

En otra cosas encontré instrucciones interesantes diferentes en internet, pude hacer este pequeño dibujo.

Con el siguiente código:

1 import turtle
   2
   3 eye = turtle.Turtle()
   4
   5 eye.screen.bgcolor("black")
   6 eye.color("white")
   7
   8 eye.speed(70)
   9
  10 for i in range(180):
  11     eye.forward(100)
  12     eye.right(30)
  13     eye.forward(20)
  14     eye.left(60)
  15     eye.forward(50)
  16     eye.right(30)
  17
  18     eye.penup()
  19     eye.setposition(0, 0)
  20     eye.pendown()
  21
  22     eye.right(2)
  23
  24 turtle.done()

¿Que es python?
Python es un lenguaje de programación interpretado de tipado dinámico cuya filosofía hace hincapié en una sintaxis que favorezca un código legible. Se trata de un lenguaje de programación multiparadigma y disponible en varias plataformas.

Interpretado
Se ejecuta sin necesidad de ser procesado por el compilador y se detectan los errores en tiempo de ejecución.
Multiparadigma
Soporta programación funcional, programación imperativa y programación orientada a objetos.
Tipado dinámico
Las variables se comprueban en tiempo de ejecución.
Multiplataforma
Disponible para plataformas de Windows, Linux o MAC.

Python Turtle Graphics
Es un módulo de programación gráfica para Python utilizado como método para enseñar programación a través de coordenadas relativas

A la tortuga es un objeto al cual se le puede dar órdenes de movimiento (avance, retroceso, giro, etc). Moviendo adecuadamente la tortuga se puede conseguir dibujar todo tipo de figuras. La tortuga dispone de 3 atributos esenciales:

• Posición: Respecto al centro de coordenadas.
• Orientación: Dirección hacia donde mira la tortuga.
• Pluma: Rastro que puede dejar la tortuga al desplazarse

Las funciones principales para animar nuestro objeto son las siguientes:

• forward(distance): Avanzar una determinada cantidad de píxeles.
• backward(distance): Retroceder una determinada cantidad de píxeles.
• left(angle): Girar hacia la izquierda un determinado ángulo.
• right(angle): Girar hacia la derecha un determinado ángulo.

Mi intento de Pikachu

Que tal! aquí esta mi ejemplo, vengo del curso de Algoritmos Básicos y apliqué recursividad para generar un espiral colorido 😄.

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()

tortuga.shape("turtle")
tortuga.pensize(5)

color = ['red','orange', 'yellow', 'green', 'blue', 'purple']

def espiral(tortuga, lenght, colorIndex):
    if (lenght > 0):
        if(colorIndex > len(color) - 1):
            colorIndex = 0
        tortuga.color(color[colorIndex])
        tortuga.forward(lenght)
        tortuga.left(30)
        espiral(tortuga, lenght-1, colorIndex+1)


espiral(tortuga, 100, 0)
window.mainloop()

Cordial Saludo, adjunto mi ejemplo espero les guste 😃

import turtle
turtle.shape("turtle")
turtle.color("red")
for i in range (1,200):
    turtle.forward(i*2)
    turtle.right(90)
window.mainloop()

Compañeros, como me surgio un problema utilizar la libreria “turtle” en Linux (especificamente en Fedroa 29), les comparto la solucion por si se les presenta algo parecido.

Al principio intente realizar un pip install turtle y todo perfecto, pero al momento de ejecutar el .py me salian errores de que no encontraba el modulo del Screen y asi con otros modulos, al investugar lei que hay otra libreria llamada exactamente igual, lo que hacen es hacer un pip uninstall turtle.

Luego de eso no deben hacer mas nada ya que la verdadera libreria turtle ya esta por default.

Luego de eso me encontre con el mismo problema de que no conoce los modulos, con lo que encontre que mee falto instalas unos paquetes de Tkinter, y para instalarlos es con el siguiente comando:

Python 2:
$ sudo dnf install python2-tkinter

Python 3:
$ sudo dnf install python3-tkinter

Y ya con esto les serviria perfectamente al ejecutar los script de esta libreria.

Despues de buscar durante toda la tarde de como carajos ejecutar el codigo de python en windows, me di cuenta que la mejor manera es visual studio code ¿Por que? porque visual studio code te da la posibilidad de ejecutar el codigo desde el editor y encontre este video que te dice paso a paso desde la instalacion de python a como agregar python a las variables de entorno y a como configurar visual studio code para python solo sigan el video paso a paso y podran continuar aprendiendo 😄
https://youtu.be/dNFgRUD2w68
De nada 😄

Ocupando Chaos Game en turtle con un nivel de conocimiento de Python medio. Dejo mi aporte para que les sirva de inspiración y vean las cosas increíbles que puede hacer Python.

import turtle
import numpy as np
import threading
import time

turtle.setup(800, 600)

#wn = turtle.Screen()
turtle.bgcolor('black')
caos = turtle.Turtle()
turtle.tracer(0, 0)

caos.speed(0)

turtle.fd(50)
caos.penup()
caos.hideturtle()
caos.ht()

random_x = np.random.randint(-350, high=350)
random_y = np.random.randint(-250, high=250)

def dibujar_punto(coordenada_x, coordenada_y, color):
    caos.color(color)
    caos.setx(coordenada_x)
    caos.sety(coordenada_y)
    return caos.dot(1)

def puntos_en_circunferencia(numero_de_puntos):
    n = numero_de_puntos
    vector_de_posiciones = []
    r = 400
    for i in range(n):
        angulo =((2 * 3.1416 * i) / n) + (0 * 3.1416/180)
        punto_x = r * np.cos(angulo)
        punto_y = r * np.sin(angulo)
        vector_de_posiciones.append(punto_x)
        vector_de_posiciones.append(punto_y)
    
    return vector_de_posiciones
        
numero_de_vertices = 5

puntos = puntos_en_circunferencia(numero_de_vertices)


j = 0
for i in range(numero_de_vertices):
    dibujar_punto(puntos[i + j], puntos[i+1+ j], 'white')
    j+=1


def fractal(num_de_puntos, pos_vertices, num_vertices, init_random_x, init_random_y):
    i = 0
    eleccion_anterior_del_punto = 000
    while i < num_de_puntos:
        eleccion_random_del_punto = np.random.randint(num_vertices)

        if eleccion_anterior_del_punto != eleccion_random_del_punto:
            l = 0
            for k in range(num_vertices):
                if  eleccion_random_del_punto == k:
                    init_random_x = (pos_vertices[k + l] + init_random_x)/2
                    init_random_y = (pos_vertices[k + 1 + l] + init_random_y)/2
                    dibujar_punto(init_random_x, init_random_y, 'cyan')
                l += 1
            i +=1
        eleccion_anterior_del_punto = eleccion_random_del_punto

fractal(50000, puntos, numero_de_vertices, random_x, random_y)

                            
turtle.mainloop()

time.sleep(2)```

import turtle

tortuga = turtle.Turtle()

for i in range(1,50):
    tortuga.circle(50)
    tortuga.right(10)

turtle.done()

Platzi Logo

import turtle

wn = turtle.Screen()
wn.bgcolor("DarkSlateGray")

t = turtle.Turtle()
t.color("LimeGreen")
t.pensize(70)

t.right(45)
t.forward(80)

t.right(90)
t.forward(170)

t.right(90)
t.forward(320)

t.right(90)
t.forward(320)

t.right(90)
t.forward(190)

t.right(90)
t.forward(100)

wn.mainloop()

Para los que recien empiezan y no saben donde encontrar un editor de código ahi les va:
sublimetext.com
atom.io
code.visualstudio.com
lighttable.com/

Si tienes este error es porque tal vez seas del 2022, te dejo esta solución que debes instalar y así te funcionará.

Saludos.

Vuelven y cometen los mismos errores del curso anterior de Python. Uno de ellos era lo mal estructurado que estaba, y el profesor hacía cosas sin ninguna explicación, como es este caso, en lo de las tortugas, y más aún cuando tienen un enfoque en introducir a la programación en los novatos. Muy mal Platzi.

Instalación y EJECUCIÓN de archivos .py

Como varios que iniciamos, tuve dificultades luego de instalar Python y tratar de ejecutar mi primer programa. Así que esta es una serie de pasos para los que tenemos Windows.

1. Instalamos la versión 3.x de Python
2. Creamos una carpeta especial donde guardaremos nuestros archivos (en mi caso, en la unidad D: en la carpeta Dev)
3. Creamos nuestro archivo fuente y lo guardamos con la extensión .py
4. Abrimos/ejecutamos CMD
5. Nos movemos a la carpeta elegida ‘D:Dev’ con los respectivos comandos de MS-DOS
6. Y una vez estemos en esa carpeta… D:\Dev>
7. escribimos
   python ejemplo.py

D:\Dev>python ejemplo.py

1. Y al dar Enter, nuestro programa se ejecutará o nos mostrará los errores

Si tienen este error:

AttributeError: module 'turtle' has no attribute 'Screen'

Probablemente sea porque el nombre del archivo que están editando es turtle.py. Cámbienle el nombre y se arregla

En esta clase el profesor no dice como instalar python, ni como instalar esa plataforma donde se escribe el codigo, es mi primera vez hace 10 min que ingreso a platzi y me dijeron que python es bueno para iniciados, pero veo que no? en que clase aprendo a como obtener esa plataforma para escribir codigo? gracias

Que tiene que ver turtle para resolver la inquietud de porque programar con python, ILÓGICO.

Hola apenas estoy aprendiendo a programar en este curso y tengo la siguiente pregunta:
Como hago para ejecutar el archivo con Atom?

Estoy haciendo la ruta de python y django, siento que me enseñan y me devuelven una y otra vez en cada inicio de cada curso.

Para los principiantes que se perdieron con turtle y aún no entienden mucho de qué va, no se frustren. De momento a menos que quieran hacer dibujos con turtle, no les aporta nada relevante a modo de introducción a la programación con Python.
Pueden saltar este video y dejarlo para volver a verlo más tarde.

en un principio me salia “partially initialized module turtle has no attribute Screen…” pero me sucedia solo porque le puse turtle.py al archivo desde donde estaba trabajando y trataba de llamarse a si mismo, lo renombre a cualquier otra cosa y me funciono, me siento tonto ahora pero espero que a alguien le sirva

import turtle

wn = turtle.Screen()
wn.bgcolor("lightgreen")
tortuga = turtle.Turtle()
tortuga.color("darkblue")

for i in range(100):
    tortuga.forward(i+3)
    tortuga.right(90)

wn.mainloop()```

APORTE

Que tal,
Me surgieron algunas dudas respecto al código que se menciona en el vídeo y en especifico en las siguientes 3 líneas:

window = turtle.Screen()
tortuga = turtle.Turtle()
window.mainloop()

Leí varios comentarios en los cuales mencionan que también han tenido problemas con algunas de esas líneas, me gustaría saber si alguien tiene alguna idea clara del porque de este error, sin embargo y como parte de mi aporte, les dejo otra forma en la que se puede correr ese mismo programa, también debo aclarar que la versión de Python que tengo instalada es la 3.8.2 y en jupyter tengo la versión 3.7.4 y en las dos versiones de Python el programa se ejecuta sin problemas

import turtle

turtle.forward(100)
turtle.right(90)

turtle.forward(100)
turtle.right(90)

turtle.forward(100)
turtle.right(90)

turtle.forward(100)
turtle.right(90)

turtle.exitonclick()    #Con esta línea se indica que la ventana no se va a cerrar hasta que le den click

Recuerden no nombrar el programa como turtle.py.

Espero les sea de utilidad

Una especie de flor :B

import turtle

window=turtle.Screen() 
tortuga = turtle.Turtle()
tortuga.shape("turtle")
tortuga.fillcolor("pink")

tortuga.begin_fill()

for i in range(36):
	tortuga.left(10)
	for i in range(4):
		tortuga.forward(200)
		tortuga.right(90)

tortuga.end_fill()
window.mainloop()```

VIM Básico: https://platzi.com/clases/1123-linux/7040-vim-y-manejo-basico/

Pude hacer esto.

import turtle


myTurtle = turtle.Turtle()

MAX_DEPTH=9

def leaf(depth=0):
    if depth > MAX_DEPTH:
        # Establecemos una condición con un valor experimental,
        return
    length=100 * (2/3)**depth
    myTurtle.forward(length)
    myTurtle.left(60)
    leaf(depth+1)
    myTurtle.right(120)
    leaf(depth+1)
    myTurtle.right(120)
    myTurtle.forward(length)
    myTurtle.left(180)


if __name__ == "__main__":
    myWin = turtle.Screen()
    leaf()
    myWin.exitonclick()

Documentación oficial de Turtle en Python

Código de muestra para hacer una estrella:

from turtle import *
color('red', 'yellow')
begin_fill()
while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break
end_fill()
done()

Buenas! A todxs lxs que quieran empezar con python les recomiendo que se descarguen Anaconda:
https://www.anaconda.com/distribution/
Anaconda es una plataforma que instala Python 3, incluye a turtle e infinidad otras de librerias (hasta tensorflow que se usa en machine learning)

Salu2

https://pythoninstitute.org/free-python-courses/ en esta pagina se pueden inscribir gratis es un curso en linea que empieza desde cero, es en ingles con la posibilidad de certificarse a través del Instituto Phyton

Aqu[i pueden encontrar mas cosas sobre la libreria de turtle. Hay cosas muy interesantes 😮
https://docs.python.org/2/library/turtle.html#turtle.forward

El comando python --version no funciona en el cmd, utiliza

import sys
print(sys.version)

Hice un polígono estrellado de 10 puntas, les adjunto el respectivo código.

import turtle

window = turtle.Screen()
estrella =turtle.Turtle()

estrella.color('green')
estrella.shape("turtle")

for i in range(10):
    estrella.forward(200) #Se mueve 200 pixeles hacia adelante
    estrella.right(108) #Gira 108 grados a la derecha

window.mainloop()

Escribiendo PLATZI con turtle, tambien les dejo las demas letras por si quieren experimentar con otros mensajes.

import turtle
import random

letras = {
    'A': ((0,0),(0.5,1),(0.75,0.5),(0.25,0.5),(0.75,0.5),(1,0)),
    'B': ((0,0),(0,1),(0.625 ,1),(0.75,0.875),(0.75,0.625),(0.625,0.5),(0,0.5),(0.625,0.5),(0.75,0.375),(0.75,0.125),(0.625,0),(0,0)),
    'C': ((0.75,0.125),(0.625,0),(0.125,0),(0,0.125),(0,0.875),(0.125,1),(0.625,1),(0.75,0.875)),
    'D': ((0,0),(0,1),(0.625 ,1),(0.75,0.875),(0.75,0.125),(0.625,0),(0,0)),
    'E': ((0.75,0),(0,0),(0,0.5),(0.75,0.5),(0,0.5),(0,1),(0.75,1)),
    'F': ((0,0),(0,0.5),(0.75,0.5),(0,0.5),(0,1),(0.75,1)),
    'G': ((0.75,0.5),(0.625,0.5),(0.75,0.5),(0.75,0.125),(0.625,0),(0.125,0),(0,0.125),(0,0.875),(0.125,1),(0.625,1),(0.75,0.875)),
    'H': ((0,0),(0,1),(0,0.5),(0.75,0.5),(0.75,1),(0.75,0)),
    'I': ((0,0),(0.25,0),(0.125,0),(0.125,1),(0,1),(0.25,1)),
    'J': ((0,0.125),(0.125,0),(0.375,0),(0.5,0.125),(0.5,1)),
    'K': ((0,0),(0,1),(0,0.5),(0.75,1),(0,0.5),(0.75,0)),
    'L': ((0,0),(0,1),(0,0),(0.75,0)),
    'M': ((0,0),(0,1),(0.5,0),(1,1),(1,0)),
    'N': ((0,0),(0,1),(0.75,0),(0.75,1)),
    'O': ((0.75,0.125),(0.625,0),(0.125,0),(0,0.125),(0,0.875),(0.125,1),(0.625,1),(0.75,0.875),(0.75,0.125)),
    'P': ((0,0),(0,1),(0.625,1),(0.75,0.875),(0.75,0.625),(0.625,0.5),(0,0.5)),
    'Q': ((0.75,0.125),(0.625,0),(0.125,0),(0,0.125),(0,0.875),(0.125,1),(0.625,1),(0.75,0.875),(0.75,0.125),(0.875,0)),
    'R': ((0,0),(0,1),(0.625,1),(0.75,0.875),(0.75,0.625),(0.625,0.5),(0,0.5),(0.625,0.5),(0.875,0)),
    'S': ((0,0.125),(0.125,0),(0.625,0),(0.75,0.125),(0.75,0.375),(0.675,0.5),(0.125,0.5),(0,0.625),(0,0.875),(0.125,1),(0.625,1),(0.75,0.875)),
    'T': ((0,1),(0.5,1),(0.5,0),(0.5,1),(1,1)),
    'U': ((0,1),(0,0.125),(0.125,0),(0.625,0),(0.75,0.125),(0.75,1)),
    'V': ((0,1),(0.375,0),(0.75,1)),
    'W': ((0,1),(0.25,0),(0.5,1),(0.75,0),(1,1)),
    'X': ((0,0),(0.375,0.5),(0,1),(0.375,0.5),(0.75,1),(0.375,0.5),(0.75,0)),
    'Y': ((0,1),(0.375,0.5),(0.375,0),(0.375,0.5),(0.75,1)),
    'Z': ((0,1),(0.75,1),(0,0),(0.75,0)),
}


tortuga = turtle.Turtle()
window = turtle.Screen()
window.bgcolor("#000000")

def displayMessage(mensaje,fontSize,color,x,y):
  tortuga.color(color)
  mensaje=mensaje.upper()

  for letra in mensaje:
    if letra in letras:
      letter = letras[letra]
      tortuga.penup()
      for dot in letter:
        tortuga.goto(x + dot[0]*fontSize, y + dot[1]*fontSize)
        tortuga.pendown()

      x += fontSize

    if letra == " ":
      x += fontSize
    x += fontSpacing

#Iniciar programa
fontSize = 30
fontSpacing = 5
fontColor = "green"

mensaje = "PLATZI"
displayMessage(mensaje,fontSize,fontColor,-100,0)
turtle.mainloop()

Hola platzinautas! 😃
Les cuento… la primera vez que vi este video tuve muchos problemas y me frustre mucho, ya que desde el minuto 3 app no entendi nada, pero por casualidades de la vida me cruce con un curso de Leonidas de Git y Github, y en ese curso aprendi el por que me quedaba estancado en este curso… pues sin mas preambulos aca les dejo los links de los videos del curso que me ayudaron a entender, y salirme del agujero en el que me encontraba.
https://platzi.com/clases/1170-git-github/8437-instalacion-y-configuracion-de-git/
https://platzi.com/clases/1170-git-github/8440-comandos-utiles-de-la-terminal/

Espero les sirva como a mi 😄

Si alguien esta interesado acerca de como usar VIM with Python les recomiendo este articulo que encontré en Real Python donde explica y da unos buenos consejos para usar el lenguaje y el editor de texto.

Hola, les comparto un pequeño curso del editor de texto que usa el profe, VIM, no esta de mas saber manipular esa potente herramienta que ya viene instalado en muchas distribuciones de gnu-linux, es ligero y poderoso, te ahorra el uso del mouse, aun el uso de las flechas! entre mas comandos conozco, mas abandonado tengo otros editores, lo puedes ver aqui: https://www.youtube.com/watch?v=iWo1cDGlNDI

recomiendo usar cmder , instalarlo y colocar python , después de ahi arranca, creo q es la solución mas fácil

Nota: en 2019 Python ya es el lenguaje número uno en el ranking. Es un lenguaje que definitivamente hay que aprender. Y el profesor explica todo muy bien. Excelente inicio del curso.

Si usan VS Code es recomiendo las extensiones, Pyhton y Code Run, con este ultimo solo tienen que presionar “Ctrl + Alt + N” y les ejecuta el programa, y ya no necesitan ir a la consola y buscar su archivo, sirve de mucho.

Dejo el código de la clase:

import turtle

window = turtle.Screen()

tortuga = turtle.Turtle()

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)


window.mainloop()```

Python where we can, C++ where we must…!!!

¿Que editor usan? he trabajado con Atom pero veo que muchos usan VSCode. ¿Qué opiniones tienen acerca de estos?

Para el momento de este comentario, en Stackoverflow, Python es el lenguaje mas popular superando a JavaScript

Buen video Cuadri jajaja, buen video por parte de David, el toque y confianza que tiene dan ganas de aprender este nuevo lenguaje.

Para los que se estén preguntando ¿ Bueno y donde esta la tortuga ? 😄
con esta par de lineas la pueden mostrar, cambiar esa flecha a la tortuga

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()

tortuga.color(‘green’)
tortuga.shape(‘turtle’)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

window.mainloop()

Para los que apenas están empezando a programar y python es su primer lenguaje,y no logran hacer lo de turtle,no se preocupen y no se estanquen, continuen con el curso a partir del siguiente video, empiezan a familiarizarse como tal con el lenguaje. Luego regresan y hacen lo de turtle.

Empezó esto. Vamos a aprender

import turtle
from turtle import *
colors = ['red', 'purple', 'blue', 'green', 'yellow', 'orange']
for x in range(360):
    pencolor(colors[x % 6])
    width(x / 100 + 1)
    forward(x)
    left(59)

otro

from turtle import *
import random

for n in range(60):
    penup()
    goto(random.randint(-400, 400), random.randint(-400, 400))
    pendown()

    red_amount   = random.randint( 0,  30) / 100.0
    blue_amount  = random.randint(50, 100) / 100.0
    green_amount = random.randint( 0,  30) / 100.0
    pencolor((red_amount, green_amount, blue_amount))

    circle_size = random.randint(10, 40)
    pensize(random.randint(1, 5))

    for i in range(6):
        circle(circle_size)
        left(60)

Esta página tiene mucha información

GitHub Turtle

Poniendome un poco creativo logre lo siguiente:

El código es el siguiente:

# -*- codign: utf-8 -*-

# Libraries
import turtle

def run():
    # Set Window
    window = turtle.Screen() # Set Object Graphic - Turtle in the actual window
    window.bgcolor("#0791e6") # Background color
    # Set Object
    turtleTemp = turtle.Turtle() # Start Object Turtle
    turtleTemp.color("white") # Set color
    # Speed Flag
    turtleTemp.speed(100)
    # Move Object
    steps = 106
    for i in range(steps):
        turtleTemp.forward(i * 2) # Steps
        turtleTemp.right(i * 10) # Angle of line
    
    # Complement
    for i in range(steps):
        count = (steps - i)
        turtleTemp.forward(count * 2) # Steps
        turtleTemp.right(count * 10) # Angle of line
        
    window.mainloop() # Make Loop to last functions
    

if __name__ == "__main__":
    run()```

Consulta. en el min 7:12 abrio la consola? o dentro de VIM? no se explicó mucho?

Para aquellas personas que esten en Medellin, Colombia, y deseen participar de encuentros en los cuales se hable de Python, me pueden escribir, hacen 2 eventos al mes al lado del centro comercial santafe para aquellos que aman el codigo en python

import turtle



window = turtle.Screen()
tortuga = turtle.Turtle()

for i in range(4):
    tortuga.forward(100)
    tortuga.right(90)

window.mainloop()

Lo hice así para no repetir el código

para los futuros estudiantes, si en algun momento les marca este error en ubuntu :
Traceback (most recent call last):
File “/home/master/Escritorio/curso/crudplatzi/turtel_square.py”, line 1, in <module>
import tkinter
ModuleNotFoundError: No module named ‘tkinter’

solo ingresen la siguiente instruccion en su terminal:
sudo apt-get install python3-tk

y con eso resuelven el problema, espere le sea de utilidad.

Lo hice con mi equipo preferido de fútbol Liverpool: LFC.

import turtle

window = turtle.Screen()

t = turtle.Turtle()
t.reset()
t.pencolor('red')
t.pensize(10)
t.penup()
t.goto(-300,200)

#L
t.pendown()
t.goto(-300,30)
t.goto(-230,30)


t.penup()
t.goto(-190,200)

#F
t.pendown()
t.goto(-190,30)
t.goto(-190,200)
t.goto(-120,200)
t.goto(-190,200)
t.goto(-190,130)
t.goto(-120,130)

t.penup()
t.goto(10,30)

#C
t.pendown()
t.circle(87,-180)


window.mainloop()

HOLAAA si no les gusta usar vim, pueden usar nano también, es el que yo estoy usando y me gusta mucho más que vim, nano es más gráfica que vim

LA PREGUNTA DEL MILENIO! como uso nano???
Muy fácil!
nano turtule_square.py
solo cambias la palabra vim por nano 😄 y listo!!

(ya viene instalado)

Recomiendo como contenido adicional el libro Think Python 2da edicion de Allen B. Downey. Usa el mismo ejemplo de turtle y explica en detalle Python.

Me da el siguiente error. Alguna ayuda? Tengo instalado python 2.7 y 3.7 ambos me dan el mismo error

viktordev@DESKTOP-LR9P6SV:~/projects/crud$ python clase01.py Traceback (most recent call last): File "clase01.py", line 1, in <module> import turtle File "/usr/lib/python2.7/lib-tk/turtle.py", line 107, in <module> import Tkinter as TK File "/usr/lib/python2.7/lib-tk/Tkinter.py", line 42, in <module> raise ImportError, str(msg) + ', please install the python-tk package' ImportError: No module named _tkinter, please install the python-tk package

En un principio, Sublime Text, Atom y VSCode NO son IDE, son editores de texto. Una de las herramientas de estos entornos de desarrollo es un editor de texto.

Que es una instancia?

pensé que era una librería limitada y me sorprendi en dos sentidos no es una librería limitada y efectivamente hay bastante documentación y una gran comunidad alrededor de Python.

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()
tortuga.reset()
tortuga.shape("circle")
tortuga.fillcolor("violet")
tortuga.pencolor("brown")
tortuga.shapesize(5,2)
window.mainloop()

Sublime Text fue programado en C++ y Python. Lo recomiendo ampliamente.

Buenos dias para todos. Un gusto integrarme al curso de Python. Para empezar, agregar mi código con turtle para dibujar la primera letra de ni nombre.
Saludos!!

import turtle

window = turtle.Screen() # para gestionar la ventana que vamos a usar
tortuga = turtle.Turtle()

tortuga.forward(100)
tortuga.right(90)     # Rotate clockwise by 90 degrees

tortuga.forward(50)
tortuga.right(90) #cantidad de grados que tiene que dar vuelta

tortuga.forward(50)
tortuga.left(90)

tortuga.forward(50)
tortuga.left(90)

tortuga.forward(50)
tortuga.right(90)

tortuga.forward(50)
tortuga.right(90)

tortuga.forward(50)
tortuga.left(90)

tortuga.forward(50)
tortuga.left(90)

tortuga.forward(50)
tortuga.right(90)

tortuga.forward(50)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(250)


window.mainloop() # para que no se cierre la ventana hasta que le digamos

turtle.done()```

Lo que me re servirá en mis proyectos de Transporte:

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()

window.screensize(200,200,"white")

tortuga.shape("turtle")
tortuga.pensize(4)
tortuga.color('#056476')
tortuga.speed(1)

tortuga.penup()
tortuga.hideturtle()
tortuga.goto(-200,0)

tortuga.pendown()
tortuga.showturtle()
tortuga.dot(10,'#056476')

tortuga.goto(-150,0)
tortuga.dot(10,'#056476')

tortuga.goto(-100,0)
tortuga.dot(10,'#056476')

tortuga.goto(-50,0)
tortuga.dot(10,'#0A8199')

tortuga.goto(0,0)
tortuga.dot(10,'#0A8199')

tortuga.goto(50,0)
tortuga.dot(10,'#0A8199')

tortuga.goto(100,0)
tortuga.dot(10,'#0CB6D8')

tortuga.goto(150,0)
tortuga.dot(10,'#0CB6D8')

tortuga.goto(200,0)
tortuga.dot(10,'#0CB6D8')

window.mainloop()```

![linea de tiempo.png](https://static.platzi.com/media/user_upload/linea%20de%20tiempo-a1733e70-088f-414e-a6a0-0c45862581b0.jpg)

Aveces te pueden faltar modulos como por ejmplo el tkinter
instalalo con

<code>
sudo apt-get install python3-tk

Hola!!, espero no faltarle el respeto, ni al profesor, ni a mis compañeros que esten en el curso; estoy perdido mal!!!.
Instale python, abri la terminal, todo bien, configure el VSC con videos de youtube (ya que en este curso no lo enseñan), pero no me esta funcionando Python en VSC, si alguien puede ayudarme les agradeceria un monton para poder continuar con el curso, tengo windows 10 por ssi cambia la configuracion en algo

En el caso de que alguien maneje una versión anterior a python 3, el código que es window=mainloop() le funcionará de la sgte manera.

turtle = mainloop()

De todas formas recomiendo actualizar a python3.
Para entender como hacerlo y dejar configurado la versión por defecto en que se ejecutará python pueden visitar los siguientes enlaces.

1. Instalar python 3
2. Configurar python3 por defecto en ubuntu

Tuve dos problemas, el primero es que NUNCA NOMBRES EL ARCHIVO COMO turtle.py

El segundo, es que quien tiene la función mainloop() es, en este caso tortuga no window, espero les sirva por si tenían la duda

tortu.left(90)

Mueve la cabecera de la tortuga 90 grados a la izquierda

tortu.color("red")

cambia el color de trazo de linea de la tortuga a rojo

tortu.up()

levanta el “la punta de lápiz del lienzo”

tortu.down()

vuelve a poner “la punta de lápiz en el lienzo”
😉

Comparto codigo para hacer un cubo, se aceptan sugerencias para mejorarlo. Dejo enlace de la documentacion completa de la libreria Documentacion

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()

def draw_square(x = 0, y = 0):
    tortuga.pu()
    tortuga.setpos(x, y)
    tortuga.pd()
    for i in range(4):    
        tortuga.fd(100)
        if (i != 3):
            tortuga.rt(90)

def draw_line(start, end):
    tortuga.pu()
    tortuga.setpos(start)            
    tortuga.pd()
    tortuga.setpos(end)


draw_square()
tortuga.rt(90)
draw_square(50, -50)

draw_line((0, 0), (50, -50))
draw_line((0, -100), (50, -150))
draw_line((100, 0), (150, -50))
draw_line((100, -100), (150, -150))

window.mainloop()```

genera una rosa y que cada linea es de un color aleatorio xD… no es la gran cosa pero fue divertido crearla

import turtle
from random import random

window = turtle.Screen()
tortuga = turtle.Turtle()
a = 2

for x in range(0, 500):
	tortuga.forward(a)
	tortuga.right(35)
	a = a + 0.3
	tortuga.pencolor(random(), random() , random())

window.mainloop()

https://www.youtube.com/watch?v=HLvifpyCk54

Hola comparto algunos ejemplos que pude visualizar:

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()


tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)
#estrella
for i in range(10):
	tortuga.forward(50)
	tortuga.right(144)

# estrella en aumento
for i in range(20):
    tortuga.forward(i * 10)
    tortuga.right(144)	

#color
tortuga.pencolor("red")
for i in range(50):
    tortuga.forward(100)
    tortuga.left(123)


window.mainloop()

les dejo un pdf recomendado para leer.
https://www.cs.auckland.ac.nz/compsci111ssc/lectures/LectureSlides/L25_Python3.pdf

Porque se debe instalar python enla computadora? y por que no se instala javascript por ejemplo?

Pues ha sido un reto porque soy novato con la línea de comandos y tuve que consultar en google varios errores jaja. Pero salió!
**Nota: si cuando tipean $Python no les sale nada, prueben con $Python3 😃

 Python es uno de los mejores lenguajes para principiantes porque tiene una sintaxis clara, una gran comunidad y esto hace que el lenguaje sea muy amigable para los que están iniciando.
 Python está diseñado para ser fácil de usar, a diferencia de otros lenguajes donde la prioridad es ser rápido y eficiente. Python no es de los lenguajes más rápidos, pero casi nunca importa.

 Es el tercer lenguaje, según Github, entre los más populares. En StackOverflow se comenta que es uno de los lenguajes que mayor popularidad está obteniendo.

 Google define a Python con la siguiente frase ““Python cuando podamos, C++ cuando necesitemos””

 https://pypi.org/ es una página de librerías de Python

 py --versión es el comando para conocer la versión que tenemos instalada de python

 py [nombre del archivo] es el comando para ejecutar nuestro programa

 Vamos a hacer el primer programa utilizando la librería turtle graphics de Python la cual viene en la instalación de Python por defecto y nos permite hacer dibujos utilizando una tortuga que funciona como un lápiz (la guía de Python para turtle la podemos consultar en https://docs.python.org/2/library/turtle.html#turtle.forward )

Primero importamos la librería con la línea de código:
Import turtle

Y luego usamos las instrucciones para arrojar algunas figuras, a continuación vamos a ver los siguientes ejemplos:

import turtle
window = turtle.screen() => crea pantalla
tortuga = turtle.Turtle()
tortuga.forward(50)
tortuga.right(90)
tortuga.forward(50)
tortuga.right(90)
tortuga.forward(50)
tortuga.right(90)
tortuga.forward(50)
tortuga.right(90)
window.mainloop() => no Cierra la ventana creada hasta que le demos cerrar
turtle.done()

turtle.fillcolor(“red”)
turtle.begin_fill()
for i in range(4):
turtle.forward(100)
turtle.right(90)
turtle.end_fill()

Dios mío…hubiera sido apropiado que el profe hubiera explicado que para tener ese archivo “turtle_square.py”, primero tocaba crearlo con el siguiente comando en la consola: touch turtle_square.py así ya tendríamos un archivo como el que tenía el profe al comienzo.

Octagono

import turtle

window = turtle.Screen()
tortuga = turtle.Turtle()

tortuga.forward(100)
tortuga.right(45)

tortuga.forward(100)
tortuga.right(45)

tortuga.forward(100)
tortuga.right(45)

tortuga.forward(100)
tortuga.right(45)

tortuga.forward(100)
tortuga.right(45)

tortuga.forward(100)
tortuga.right(45)

tortuga.forward(100)
tortuga.right(45)

tortuga.forward(100)
tortuga.right(45)

window.mainloop()```

Que onda chaviza, a mi me dio el siguiente error, estoy usando debian 9:
Traceback (most recent call last):
File “/usr/lib/python3.5/tkinter/init.py”, line 36, in <module>
import _tkinter
ImportError: No module named ‘_tkinter’

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
File “turtle_square.py”, line 1, in <module>
import turtle
File “/usr/lib/python3.5/turtle.py”, line 107, in <module>
import tkinter as TK
File “/usr/lib/python3.5/tkinter/init.py”, line 38, in <module>
raise ImportError(str(msg) + ‘, please install the python3-tk package’)
ImportError: No module named ‘_tkinter’, please install the python3-tk package

Para solucionarlo use el siguiente comando:
sudo apt-get install python3-tk

Hola compañeras(os), hice tal cual el ejercicio y cuando lo ejecute me salió este error en consola

AttributeError: '_Screen' object has no attribute 'mainloop'

investigando, encontré que esto sale si no tienes python3, (el cual si tengo), pero necesitaba poner python3 nombre_archivo.py y así el problema se resuelve.

en fin, aquí algunos links que me ayudaron con el problema 😃

Estoy con ubuntu 18.04 LTS y ya viene con python3 instalado

Hice el ejercicio y al ejecutar

python3 turtle_square.py 

me generaba el siguiente error

Traceback (most recent call last):
  File "turtle_square.py", line 10, in <module>
    window.mailloop()
AttributeError: '_Screen' object has no attribute 'mailloop'

Leyendo e investigando encontré que toca instalar lo siguiente

Python3: apt-get install python3-tk
Python2.7 apt-get install python-tk

Espero les funcione

Por primera vez en la vida use la hipotenusa de un triangulo rectángulo.

#Comparto mi versión del ejercicio, utilizando bucle for.

import turtle

window = turtle.Screen()
tortuguita = turtle.Turtle()
turtle.color("Deep Sky Blue")
turtle.shape('turtle')

grados = 0


tortuguita.speed(10)
for x in range(1,50):
    for x in range(0,4):    
        tortuguita.forward(200)
        tortuguita.left(105)
        tortuguita.left(grados + 10)
        
window.mainloop()

Código para hacer una figura bien perrona

import turtle

window=turtle.Screen()
tortuga = turtle.Turtle()

for i in range(6):
    tortuga.forward(100)
    tortuga.left(120)
    

    tortuga.forward(100)
    tortuga.left(120)

    tortuga.forward(100)
    tortuga.left(180)

    tortuga.forward(100)
    tortuga.right(150)

    tortuga.forward(87)
    tortuga.left(150)

    tortuga.forward(50)
    tortuga.left(120)

    tortuga.forward(50)
    tortuga.left(120)

    tortuga.forward(50)
    tortuga.left(60)

    tortuga.forward(50)
    tortuga.right(60)

tortuga.right(120)
tortuga.forward(50)
tortuga.left(30)

for i in range(6):
    
    tortuga.forward(87)
    tortuga.left(60)

tortuga.forward(87)
tortuga.left(90)

tortuga.forward(150)

for i in range(2):
    tortuga.left(120)
    tortuga.forward(150)

tortuga.left(180)
tortuga.forward(75)
tortuga.right(120)

for i in range(3):
    
    tortuga.forward(75)
    tortuga.left(120)

window.mainloop()

mostrar n pentagonos

import turtle

def main():
    window = turtle.Screen()
    dave = turtle.Turtle()
    window.screensize(400)

    n = int(input("cuantos pentagonos quieres:"))
    length = int(input("De que largo los quieres:"))

  

    for i in range(n):
        make_penagono(dave, length)
        length += 40

    window.mainloop()

def make_penagono(dave, length):
    for i in range(8):
        dave.forward(length)
        dave.right(45)
    make_space(dave)

def make_space(dave):
    dave.left(45)
    dave.forward(10)
    dave.left(45)
    dave.forward(10)
    dave.right(90)

if __name__ == '__main__':
    main()```

import turtle

window = turtle.Screen()
turtle.shape("turtle")
turtle.color("blue")


def run():

    for i in range (1, 100):
        turtle.forward(i*2)
        turtle.left(60)
        
    

if __name__ == "__main__":
    run()
    input()

no me sirve turtle

<window = turtle.Screen()
tortuga= turtle.Turtle()

i=0 

while i < 1200:
    color= random.choice(['red', 'purple', 'green', 'blue', 'black'])
    tortuga.forward(1*i)
    tortuga.right(45)
    
    tortuga.forward(1*i)
    tortuga.right(90)
    
    tortuga.color(color)
    i += 1
    

window.mainloop()>

1 crear archivo

touch turtle_square.py

import turtle

window = turtle.Screen()
tortuga  = turtle.Turtle()

tortuga.forward(100)
tortuga.right(90)


tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.right(90)

tortuga.forward(100)
tortuga.left(90)

tortuga.forward(100)
tortuga.left(90)

tortuga.forward(100)
tortuga.left(90)

tortuga.forward(100)
tortuga.left(90)





window.mainloop()

Lo hice aleatorio este es el código, pinta 500 puntos de diferentes colores, no pude poner la imagen no se porque:

# -- coding: utf8 --
import turtle 
from turtle import *
import math
import random



screensize(1000, 1000)

window = turtle.Screen()

tortuga = turtle.Turtle()

tortuga.penup()

colormode(255)

contador = 0

for i in range(1,500):
    movimiento = random.randrange(1,200)
    angulo =random.randrange(1,359)
    rojo = random.randrange(0,250)
    verde = random.randrange(0,250)
    azul = random.randrange(0,250)
    tamanio = random.randrange(1,100)
    iniy = random.randrange(-300,300)
    inix = random.randrange(-300,300)

    tortuga.left(angulo)
    tortuga.forward(movimiento)
    tortuga.dot(tamanio,rojo,verde,azul)
    contador = contador + movimiento
    
    if contador > 1000:
        tortuga.goto(inix, iniy)
        contador = 0
        



turtle.done()

window.mainloop()

Por acá dejo mi código, dibuje varias figuras basadas en triangulos y circulos que se repiten.

import turtle

myPen = turtle.Turtle()
myPen.speed(0)
myPen.color("#3498eb")
myPen.pensize(2)
myPen.penup()
myPen.goto(0,0)
myPen.pendown()

def triangle (side, increment, iteration):

    myPen.left(180)
    myPen.forward(side)
    count = 0
    while count < iteration:
        side += increment
        myPen.right(120)
        myPen.forward(side)
        count += 1

def inclinedTriangle(side, decrement, iteration):
    
    myPen.left(210)
    myPen.forward(side)
    count = 1
    while count < iteration:
        side -= decrement
        myPen.right(123)
        myPen.forward(side)
        count += 1

def circles(iteration, size, angle, recurse):

    count = 1
    while count < iteration:
        myPen.forward(size)
        myPen.right(angle)
        count += 1
    myPen.penup()
    myPen.goto(0,0)
    myPen.pendown()
    if 0 < recurse :
        recurse -= 1
        circles(iteration, size, angle, recurse)

# triangle(20, 10, 50)
# inclinedTriangle(300, 3, 94)
# inclinedTriangle(300, 0, 80)
circles(24, 26, 15, 30)

turtle.done()

Soy nuevo en el mundo de la programación. Acá les dejo el circuo que realice utilizando los ejemplos de la comunidad

import _tkinter # If this fails your Python may not be configured for Tk
ImportError: libtk8.6.so: cannot open shared object file: No such file or directory

Este error viene dado por falta de la libreria libtk, para solventarlo

ARCH Linux
sudo pacman -S tk

Debian o Ubuntu
sudo apt-get install tk

Empezamos

import turtle 

objeto = turtle.Turtle()

objeto.speed(10)

for i in range(180):
    objeto.forward(100)
    objeto.right(30)
    objeto.forward(20)
    objeto.left(60)
    objeto.forward(50)
    objeto.right(30)
    
    objeto.penup()
    objeto.setposition(0, 0)
    objeto.pendown()
    
    objeto.right(2)
    
turtle.done()