#!/usr/bin/env python3

print("Hola🙂️")

In [11]: type(34)
Out[11]: int

In [12]: type(34.3)
Out[12]: float

In [13]: type(True)
Out[13]: bool

In [14]: type("hola")
Out[14]: str

In [1]: print('C:\some\name')
C:\some
ame
In [2]: print(r'C:\some\name')
C:\some\name

#!/usr/bin/env python3

BOX = """
+----------+
|          |
+----------+
"""

print(BOX)
print(BOX)

#!/usr/bin/env python3

BOX = """\
+----------+
|          |
+----------+\
"""

print(BOX)
print(BOX)

#!/usr/bin/env python3

#-- Estos mensajes se imprimen en la misma línea
print("-Mensaje 1-"
      "-Mensaje 2-")

#!/usr/bin/env python3

#-- Anchura de la linea
width = 20

#-- Dibujar linea de la anchura indicada
print("─" * width)

#!/usr/bin/env python3

#-- Anchura de la linea
width = 20
MESSAGE = "MENU"
INDENT = 3

#-- Dibujar linea de la anchura indicada
print("─" * width)

#-- Imprimir el mensaje con indentado
print (" " * INDENT + MESSAGE)

#-- Dibujar linea inferior
print("─" * width)

In [20]: cad="012345"

In [21]: cad[0]
Out[21]: '0'

In [22]: cad[5]
Out[22]: '5'

In [23]: cad[-1]
Out[23]: '5'

In [24]: cad[-2]
Out[24]: '4'

In [1]: cad="012345"

In [2]: cad[0:2]
Out[2]: '01'

In [3]: cad[1:3]
Out[3]: '12'

In [4]: cad[:3]
Out[4]: '012'

In [5]: cad[-2:]
Out[5]: '45'

In [6]:

In [13]: cad="012345"

In [14]: i=3

In [15]: cad[:i] + cad[i:]
Out[15]: '012345'

In [16]: cad[:i] + "|" + cad[i:]
Out[16]: '012|345'

In [17]:

In [21]: cad="012345"

In [22]: cad[4:10]
Out[22]: '45'

In [23]: cad[6:10]
Out[23]: ''

In [24]: 

In [26]: cad="012345"

In [27]: cad[0]='A'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-27-c266e78be102> in <module>
----> 1 cad[0]='A'

TypeError: 'str' object does not support item assignment

In [28]: 

In [29]: cad="012345"

In [30]: len(cad)
Out[30]: 6

# Código ANSI para cambiar el color del texto a rojo
print('\033[91m' + 'Texto rojo' + '\033[0m')

# Código ANSI para cambiar el color del fondo a amarillo
print('\033[43m' + 'Texto con fondo amarillo' + '\033[0m')

# Código ANSI para cambiar el color del texto a verde y el fondo a azul
print('\033[32;44m' + 'Texto verde con fondo azul' + '\033[0m')

#!/usr/bin/env python3

#-- Definiciones ANSI para los colores
RED = "\x1B[91m"  

#------ Otros caracteres especiales
#-- Volver al color por defecto
DEFAULT = "\x1B[0m"

#-- Imprimir mensaje en Rojo
print(RED + "Mensaje en color rojo" + DEFAULT)

#-- Imprimir mensaje normal
print("Este es un mensaje normal...")

#!/usr/bin/env python3

#-- Definiciones ANSI para los colores
NEGRO = "\x1B[30m"
RED = "\x1B[31m"  
GREEN = "\x1B[32m" 
YELLOW = "\x1B[33m"
BLUE = "\x1B[34m"
MAGENTA = "\x1B[35m"
CYAN = "\x1B[36m"
WHITE = "\x1B[37m"

#------ Otros caracteres especiales
#-- Volver al color por defecto
DEFAULT = "\x1B[0m"

#-- Imprimir mensajes en diferentes colores
print(NEGRO + "Mensaje en negro")
print(RED + "Mensaje en color rojo")
print(GREEN + "Mensaje en color verde")
print(YELLOW + "Mensaje en color amarillo")
print(BLUE + "Mensaje en azul")
print(MAGENTA + "Mensaje en magenta")
print(CYAN + "Mensaje en Cyan")
print(WHITE + "Mensaje en blanco")

#-- Imprimir mensaje normal
print(DEFAULT + "Este es un mensaje normal...")

#!/usr/bin/env python3

#───────────────────────────────────────
# Definiciones ANSI para los colores
#───────────────────────────────────────

#── Colores normales
GREY = "\x1B[30m"
RED = "\x1B[31m"  
GREEN = "\x1B[32m" 
YELLOW = "\x1B[33m"
BLUE = "\x1B[34m"
MAGENTA = "\x1B[35m"
CYAN = "\x1B[36m"
WHITE = "\x1B[37m"

#── Colores brillantes
LGRAY = "\x1B[90m"
LRED = "\x1B[91m"
LGREEN = "\x1B[92m"
LYELLOW = "\x1B[93m"
LBLUE = "\x1B[94m"
LMAGENTA = "\x1B[95m"
LCYAN = "\x1B[96m"
LWHITE = "\x1B[97m"

#──── Otros caracteres especiales
#── Volver al color por defecto
DEFAULT = "\x1B[0m"

#── Imprimir mensajes en diferentes colores
print(GREY + "Mensaje en Gris")
print(LGRAY + "Mensaje en gris claro")

print(RED + "Mensaje en color rojo")
print(LRED + "Mensaje en Rojo claro")

print(GREEN + "Mensaje en color verde")
print(LGREEN + "Mensaje en color verde claro")

print(YELLOW + "Mensaje en color amarillo")
print(LYELLOW + "Mensaje en color amarillo claro")

print(BLUE + "Mensaje en azul")
print(LBLUE + "Mensaje en azul claro")

print(MAGENTA + "Mensaje en magenta")
print(LMAGENTA + "Mensaje en magenta claro")

print(CYAN + "Mensaje en Cyan")
print(LCYAN + "Mensaje en Cyan claro")

print(WHITE + "Mensaje en blanco")
print(LWHITE + "Mensaje en blanco claro")


#── Imprimir mensaje normal
print(DEFAULT + "Este es un mensaje normal...")

In [1]: l = [0,1,2,3,4,5,6]

In [2]: l[-1]
Out[2]: 6

In [3]: l[0]
Out[3]: 0

In [4]: l[0:2]
Out[4]: [0, 1]

In [1]: l1 = [0,2,3,4,5,6]

In [2]: l2 = l1

In [3]: l1, l2
Out[3]: ([0, 2, 3, 4, 5, 6], [0, 2, 3, 4, 5, 6])

In [4]: l2[0]='a'

In [5]: l1, l2
Out[5]: (['a', 2, 3, 4, 5, 6], ['a', 2, 3, 4, 5, 6])

In [6]: l3 = l1[:]

In [7]: l1,l2,l3
Out[7]: (['a', 2, 3, 4, 5, 6], ['a', 2, 3, 4, 5, 6], ['a', 2, 3, 4, 5, 6])

In [8]: l3[0]='f'

In [9]: l1,l2,l3
Out[9]: (['a', 2, 3, 4, 5, 6], ['a', 2, 3, 4, 5, 6], ['f', 2, 3, 4, 5, 6])

In [1]: l = ['a', 'b', 'c', 'd']

In [2]: l[1:3]=['B', 'C']

In [3]: l
Out[3]: ['a', 'B', 'C', 'd']

In [4]: l[1:3]=[]

In [5]: l
Out[5]: ['a', 'd']

In [1]:  l = ['a', 'b', 'c', 'd']

In [2]: len(l)
Out[2]: 4

#!/usr/bin/env python3

a, b = 0, 1
while a < 10:
    print(a)
    a, b = b, a+b

#!/usr/bin/env python3

a, b = 0, 1
while a < 10:
    print(a, end=",")
    a, b = b, a+b

print()

#!/usr/bin/env python3

cad = input("Introduzca una cadena: ") 
print("Has escrito: " + cad)

#!/usr/bin/env python3

num = int(input("Introduzca un número: "))
print("El número es: " + str(num))

#!/usr/bin/env python3

num = int(input("Introduce un número: "))

if num < 0:
    print("Número negativo")
elif num == 0:
    print("Es 0")
else:
    print("Número positivo")

#!/usr/bin/env python3

words = ["hola", "probando", "1234567890"]

for w in words:
    print(w, len(w))

#!/usr/bin/env python3

#-- Crear una coleccion simple
users = {
    "Obijuan": "activo",
    "Dark vader": "inactivo",
    "Yoda": "activo",
    "luke skywalker": "inactivo"
}

#-- Eliminar los usuarios inactivos

#-- Estrategia 1: Iterar sobre una copia, 
#-- borrar de la colección original
#-- users.copy() es una copia
for user, estado in users.copy().items():
    if estado == "inactivo":
        del users[user]

print(users)

#-- Estrategia 2: Crear una lista nueva
user_activos = {}
for user, estado in users.items():
    if estado == "activo":
        user_activos[user] = estado

print(user_activos)

#!/usr/bin/env python3

for i in range(10):
    print(i)

In [1]: list(range(5,10))
Out[1]: [5, 6, 7, 8, 9]

In [2]: list(range(0,10,3))
Out[2]: [0, 3, 6, 9]

In [3]: list(range(-10,-100,-30))
Out[3]: [-10, -40, -70]

#!/usr/bin/env python3

a = ["Obijuan", "Darth Vader", "Yoda", "Han Solo"]

#-- Recorrer la lista usando los índices
for i in range(len(a)):
    print(i, a[i])

In [1]: sum(range(4))
Out[1]: 6

#!/usr/bin/env python3

#-- Calcular la divisibilidad de los numeros entre 2 y 10
for n in range(2, 10):

    #-- Dividir n entro todos los numeros inferiores a n
    for x in range(2, n):

        #-- Numero divisible
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break

    #-- No es divisible
    else:
        # loop fell through without finding a factor
        print(n, 'is a prime number')

#!/usr/bin/env python3

#-- Catalogar los números del 2 al 10
#-- entre pares e impares
for n in range(2,10):

    #-- Divisible entre 2: par
    if n % 2 == 0:
        print(n, "es par")

        #-- Pasar a la siguiente iteración
        continue

    #-- Es impar
    print(n, "es Impar")

#!/usr/bin/env python3

#-- Esperar hasta que se apriete Ctrl-C 
while True:
    pass

#!/usr/bin/env python3

print("1.- Opcion 1")
print("2.- Opcion 2")
print("3.- Terminar")

while True:
    op = int(input("Elige opcion: "))

    match(op):
        case 1: 
            print("Opción 1")
        case 2:
            print("Opción 2")
        case 3:
            print("Terminar")
            break
        case _:
            print("Opción inválida")

#!/usr/bin/env python3

#- Lista de puntos cartesianos
puntos = [(0,0), (0,3), (5,0), (7,9), (-3,5)]

#-- Recorrer todos los puntos
for p in puntos:

    #-- Imprimr el tipo de punto
    match(p):
        case (0,0): 
            print("* Origen")
        case (0,x):
            print("* Sobre eje X")
        case (y,0):
            print("* Sobre eje Y")
        case (x,y):
            print("* Punto (",x,y,")")

#!/usr/bin/env python3

#-- Imprimir los numeros de fibonacci hasta el número n
def fibo(n: int):
    a,b = 0,1

    while b < n:
        print(b, end=" ")
        a,b = b, a+b

#-- Llamar a la funcion
fibo(100)

#!/usr/bin/env python3


#-- Imprimir los numeros de fibonacci hasta el número n
def fibo(n: int) -> list:
    """Lista con los numeros de fibonacci hasta el numero n"""
    a,b = 0,1

    #- Lista donde almacenar la lista de fibonacci
    result = []

    while b < n:
        #-- Añadir elemento a la lista
        result.append(b)
        
        #-- Actualizar termino de fibonacci
        a,b = b, a+b

    #-- Devolver la lista
    return result


#-- Llamar a la funcion
l=fibo(100)
print("Lista de fibonacci: ", l)

#!/usr/bin/env python3

def ask_ok(prompt : str, retries=4, remainder="Please, try again") -> bool:
    """Esperar respuesta de confirmación"""

    while True:
        ok = input(prompt)

        if ok in ('s', 'si'):
            return True
        if ok in ('n', 'no', 'nope'):
            return False
        
        retries = retries - 1;

        if retries < 0:
            raise ValueError('Respuesta inválida')
        
        print(remainder)

#-- Mensaje al usuario
while True:
  if ask_ok("Quiere terminar?"):
      break

ask_ok("fin?", retries=1)

#!/usr/bin/env python3

#-- Funcion con parámetros variables (ninguno, uno, dos....)
def debug(*args):
    print("LLamada")
    print("  Tupla: ", args)
    print("  Argumentos pasados: ", len(args))

    #-- Imprimri todos los argumetnos pasados
    print("  ", end='')
    for arg in args:
        print(arg, end=' ')
    print()


#-- Llamar a la función con diferentes parámetros
debug()
debug(1)
debug(1,"hola")
debug(1,2,3,4)

In [1]: l = list(range(10))

In [2]: l
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: print(l)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [4]: print(*l)
0 1 2 3 4 5 6 7 8 9

In [5]: print(0,1,2,3,4,5,6,7,8,9)
0 1 2 3 4 5 6 7 8 9

In [6]: 

#!/usr/bin/env python3

#-- Funcion con parámetros clave pasados a través de un diccionario
def debug(**args):
    print("LLamada")
    print("  Diccionario: ", args)
    print("  Argumentos pasados: ", len(args))

    # #-- Imprimir todos los argumetnos pasados
    for arg in args:
         print("   ", arg, "---> ", args[arg])
    print()


#-- Llamar a la función con diferentes parámetros
debug()
debug(a1=1, a2=2)
debug(a=1, b="hola", c="vamos")

In [1]: #-- Crear pila

In [2]: pila = []

In [3]: #-- Push(1)

In [4]: pila.append(1)

In [5]: pila
Out[5]: [1]

In [6]: #-- Push(2)

In [7]: pila.append(2)

In [8]: #-- Push(3)

In [9]: pila.append(3)

In [10]: pila
Out[10]: [1, 2, 3]

In [11]: pila.pop()
Out[11]: 3

In [12]: pila
Out[12]: [1, 2]

In [13]: pila.pop()
Out[13]: 2

In [14]: pila.pop()
Out[14]: 1

In [15]: pila
Out[15]: []

In [16]: 

In [1]: from collections import deque

In [2]: cola = deque([])

In [3]: cola
Out[3]: deque([])

In [4]: cola.append("uno")

In [5]: cola.append("dos")

In [6]: cola
Out[6]: deque(['uno', 'dos'])

In [7]: cola.append("tres")

In [8]: cola
Out[8]: deque(['uno', 'dos', 'tres'])

In [9]: cola.popleft()
Out[9]: 'uno'

In [10]: cola.popleft()
Out[10]: 'dos'

In [11]: cola.popleft()
Out[11]: 'tres'

In [12]: cola
Out[12]: deque([])

In [13]: 

#!/usr/bin/env python3

#-- Crear un diccionario
notas = {
    "pepe" : 5,
    "john" : 10,
    "Vader": 8
}

#-- Recorrer diccionario obteniendo los
#-- pares clave/valor
for k,v in notas.items():
    print(k, v)

#!/usr/bin/env python3

for i,v in enumerate(["obijuan", "vader", "yoda"]):
    print(i, v)

!/usr/bin/env python3

canal1 = ["a1", "a2", "a3"]
canal2 = ["b1", "b2", "b3"]

for a,b in zip(canal1, canal2):
    print("Par de muestras:", a, b)

#!/usr/bin/env python3

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

obijuan@Hoth:~/Develop/Learn-python/Examples/Python-tutorial/Capitulo-06
$ ipython3
Python 3.10.6 (main, Mar 10 2023, 10:55:28) [GCC 11.3.0]
Type 'copyright', 'credits' or 'license' for more information
IPython 7.31.1 -- An enhanced Interactive Python. Type '?' for help.

In [1]: import fibo

In [2]: fibo.fib(5)
0 1 1 2 3 

In [3]: fibo.fib2(10)
Out[3]: [0, 1, 1, 2, 3, 5, 8]

In [4]:

obijuan@Hoth:~/Develop/Learn-python/Examples/Python-tutorial/Capitulo-06
$ ipython3
Python 3.10.6 (main, Mar 10 2023, 10:55:28) [GCC 11.3.0]
Type 'copyright', 'credits' or 'license' for more information
IPython 7.31.1 -- An enhanced Interactive Python. Type '?' for help.

In [1]: import fibo as fib

In [2]: fib.fib(5)
0 1 1 2 3 

In [3]: 

#!/usr/bin/env python3

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

#-- Codigo que se ejecuta al importar el modulo
print("--> Modulo Fibonacci")

$ ipython3
Python 3.10.6 (main, Mar 10 2023, 10:55:28) [GCC 11.3.0]
Type 'copyright', 'credits' or 'license' for more information
IPython 7.31.1 -- An enhanced Interactive Python. Type '?' for help.

In [1]: import fibo as fib
--> Modulo Fibonacci

In [2]:

#!/usr/bin/env python3

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

#-- Codigo que se ejecuta al importar el modulo
print("--> Modulo Fibonacci")

if __name__ == '__main__':
    import sys
    print("Llamando a la función fib()...")
    fib(int(sys.argv[1]))

obijuan@Hoth:~/Develop/Learn-python/Examples/Python-tutorial/Capitulo-06
$ python3 fibo.py 10
--> Modulo Fibonacci
Llamando a la función fib()...
0 1 1 2 3 5 8 
obijuan@Hoth:~/Develop/Learn-python/Examples/Python-tutorial/Capitulo-06
$

#!/usr/bin/env python3

import mi_paquete.fibo

mi_paquete.fibo.fib(10)

#!/usr/bin/env python3

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\033[u"

#───────────────────────────────────────
# MAIN
#───────────────────────────────────────
#── Nada más empezar se guarda la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

#-- Imprimir mensaje en primer linea
print("HolaHola")

#-- Recuperar la posicion del cursor
print(CURSOR_POP, end='', flush=True)

#-- Escribir puntos encima, para borrar los caracteres anteriores
print("...")

#!/usr/bin/env python3

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\033[u"

#───────────────────────────────────────
# MAIN
#───────────────────────────────────────

#── Guardar la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

#-- Imprimir mensaje en primer linea
print("HolaHola")

while True:

    #-- Recuperar la posicion del cursor
    print(CURSOR_POP, end='', flush=True)

    #-- Escribir puntos encima, para borrar los caracteres anteriores
    print("...")

#!/usr/bin/env python3

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\x1B[u"

#──── Ocultar el cursor
CURSOR_HIDE = "\x1B[?25l"

#──── Mostrar el cursor
CURSOR_SHOW = "\x1B[?25h"

#───────────────────────────────────────
# MAIN
#───────────────────────────────────────

print(CURSOR_HIDE, end='', flush=True)

#── Guardar la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

#-- Imprimir mensaje en primer linea
print("HolaHola")

try:
  while True:

    #-- Recuperar la posicion del cursor
    print(CURSOR_POP, end='', flush=True)

    #-- Escribir puntos encima, para borrar los caracteres anteriores
    print("...")

except KeyboardInterrupt:
  ##- Volver a hacer el cursor visible
  print(CURSOR_SHOW)

#!/usr/bin/env python3

import time

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\x1B[u"

#──── Ocultar el cursor
CURSOR_HIDE = "\x1B[?25l"

#──── Mostrar el cursor
CURSOR_SHOW = "\x1B[?25h"

#───────────────────────────────────────
# MAIN
#───────────────────────────────────────

#-- Ocultar cursor
print(CURSOR_HIDE, end='', flush=True)

#── Guardar la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

for i in range(0,10):
  print(i, CURSOR_POP, end='', flush=True)
  time.sleep(1)

##- Volver a hacer el cursor visible
print(CURSOR_SHOW)

#!/usr/bin/env python3

import time

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\x1B[u"

#──── Ocultar el cursor
CURSOR_HIDE = "\x1B[?25l"

#──── Mostrar el cursor
CURSOR_SHOW = "\x1B[?25h"

#───────────────────────────────────────
# MAIN
#───────────────────────────────────────

#-- Ocultar cursor
print(CURSOR_HIDE, end='', flush=True)

#── Guardar la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

#-- Imprimir plantilla barra de progreso
print("░" * 10)


print(CURSOR_POP, end='', flush=True)

for i in range(0,10):
   print("█", end='', flush=True)
   time.sleep(0.1)

##- Volver a hacer el cursor visible
print(CURSOR_SHOW)

#!/usr/bin/env python3

import time

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\x1B[u"

#──── Ocultar el cursor
CURSOR_HIDE = "\x1B[?25l"

#──── Mostrar el cursor
CURSOR_SHOW = "\x1B[?25h"

def print_frame(frame):
   """Print a frame on the console
   """
   #-- Print the frame, line by line
   for line in frame:
      print(line)


#──── The sprite is composed of frames
SPRITE = [
   [ 
    "● ",  #-- Frame 0
    "  "
   ],
   [
    " ●",  #-- Frame 1
    "  "
   ],
   [
   "  ",   #-- Frame 2
   " ●"
   ],
   [
   "  ",   #-- Frame 3
   "● "
   ]
]


#───────────────────────────────────────
# MAIN
#───────────────────────────────────────

#-- Frame period, in seconds
WAIT = 0.2

#-- Ocultar cursor
print(CURSOR_HIDE, end='', flush=True)

#── Guardar la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

try:

   #-- La animación se repite hasta que se pulse Ctrl-C
   while True:

      #-- Imprimir todos los frames, uno tras otro
      for frame in SPRITE:
         print(CURSOR_POP, end='', flush=True)
         print_frame(frame)

         time.sleep(WAIT)

#── Se ha pulsado Ctrl-C: Terminar
except KeyboardInterrupt:
   print()
   print()

   ##- Volver a hacer el cursor visible
   print(CURSOR_SHOW)

#!/usr/bin/env python3

import time

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\x1B[u"

#──── Ocultar el cursor
CURSOR_HIDE = "\x1B[?25l"

#──── Mostrar el cursor
CURSOR_SHOW = "\x1B[?25h"

def print_frame(frame):
   """Print a frame on the console
   """
   #-- Print the frame, line by line
   for line in frame:
      print(line)


#──── Sprite de digitos
DIGITOS = [
    ["●●●●",  #-- Numero 0
     "●  ●",
     "●  ●",
     "●  ●",
     "●●●●",],

    ["   ●",  #-- Numero 1
     "   ●",
     "   ●",
     "   ●",
     "   ●"],

    ["●●●●",  #-- Numero 2
     "   ●",
     "●●●●",
     "●   ",
     "●●●●"],

    ["●●●●",  #-- Numero 3
     "   ●",
     "●●●●",
     "   ●",
     "●●●●"],

    ["●  ●", #-- Numero 4
     "●  ●",
     "●●●●",
     "   ●",
     "   ●"],

    ["●●●●",  #-- Numero 5
     "●    ",
     "●●●●",
     "   ●",
     "●●●●"],

    ["●   ",  #-- Numero 6
     "●   ",
     "●●●●",
     "●  ●",
     "●●●●"],

    ["●●●●",  #-- Numero 7
     "   ●",
     "   ●",
     "   ●",
     "   ●"],

    ["●●●●",  #-- Numero 8
     "●  ●",
     "●●●●",
     "●  ●",
     "●●●●"],

    ["●●●●",  #-- Numero 9
     "●  ●",
     "●●●●",
     "   ●",
     "   ●"],
  
]

#───────────────────────────────────────
# MAIN
#───────────────────────────────────────

#-- Frame period, in seconds
WAIT = 0.5

#-- Ocultar cursor
print(CURSOR_HIDE, end='', flush=True)

#── Guardar la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

try:

   #-- La animación se repite hasta que se pulse Ctrl-C
   while True:

      #-- Imprimir todos los frames, uno tras otro
      for dig in DIGITOS:
         print(CURSOR_POP, end='', flush=True)
         print_frame(dig)

         time.sleep(WAIT)

#── Se ha pulsado Ctrl-C: Terminar
except KeyboardInterrupt:
   print()
   print()

   ##- Volver a hacer el cursor visible
   print(CURSOR_SHOW)

#!/usr/bin/env python3

import time

#───────────────────────────────────────
# Definiciones ANSI para el cursor
#───────────────────────────────────────

#──── Almacenar la posicion actual del cursor
CURSOR_PUSH = "\x1B[s"

#──── Recuperar la posicion del cursor previamente guardada
CURSOR_POP = "\x1B[u"

#──── Ocultar el cursor
CURSOR_HIDE = "\x1B[?25l"

#──── Mostrar el cursor
CURSOR_SHOW = "\x1B[?25h"

def print_frame(frame):
   """Print a frame on the console
   """
   #-- Print the frame, line by line
   for line in frame:
      print(line)


#──── Sprite de digitos
DIGITOS = [
    ["┌──┐",  #-- Numero 0
     "│  │",
     "│  │",
     "│  │",
     "└──┘",],
 
    ["   ╷",  #-- Numero 1
     "   │",
     "   │",
     "   │",
     "   ╵"],

    ["╶──┐",  #-- Numero 2
     "   │",
     "┌──┘",
     "│   ",
     "└──╴"],

    ["╶──┐",  #-- Numero 3
     "   │",
     "╶──┤",
     "   │",
     "╶──┘"],

    ["╷  ╷", #-- Numero 4
     "│  │",
     "└──┤",
     "   │",
     "   ╵"],

    ["┌──╴",  #-- Numero 5
     "│    ",
     "└──┐",
     "   │",
     "╶──┘"],

    ["╷   ",  #-- Numero 6
     "│   ",
     "├──┐",
     "│  │",
     "└──┘"],

    ["╶──┐",  #-- Numero 7
     "   │",
     "   │",
     "   │",
     "   ╵"],

    ["┌──┐",  #-- Numero 8
     "│  │",
     "├──┤",
     "│  │",
     "└──┘"],

    ["┌──┐",  #-- Numero 9
     "│  │",
     "└──┤",
     "   │",
     "   ╵"],
  
]

#───────────────────────────────────────
# MAIN
#───────────────────────────────────────

#-- Frame period, in seconds
WAIT = 0.5

#-- Ocultar cursor
print(CURSOR_HIDE, end='', flush=True)

#── Guardar la posicion del cursor
print(CURSOR_PUSH, end='', flush=True)

try:

   #-- La animación se repite hasta que se pulse Ctrl-C
   while True:

      #-- Imprimir todos los frames, uno tras otro
      for dig in DIGITOS:
         print(CURSOR_POP, end='', flush=True)
         print_frame(dig)

         time.sleep(WAIT)

#── Se ha pulsado Ctrl-C: Terminar
except KeyboardInterrupt:
   print()
   print()

   ##- Volver a hacer el cursor visible
   print(CURSOR_SHOW)

# Pedir al usuario que ingrese un número entero
decimal = int(input("Introduce un número entero: "))

# Convertir a binario
binario = bin(decimal)

# Imprimir el resultado
print(f"El número {decimal} en binario es {binario}.")

# Pedir al usuario que ingrese un número entero
decimal = int(input("Introduce un número entero: "))

# Convertir a binario y rellenar con ceros a la izquierda hasta tener 8 dígitos
binario = bin(decimal)[2:].zfill(8)

# Imprimir el resultado
print(f"El número {decimal} en binario es {binario}.")

> En este programa, utilizamos la función input() para pedirle al usuario que ingrese un número entero. Luego, usamos la función bin() para convertir el número decimal a binario. La parte [2:] se utiliza para quitar los primeros dos caracteres de la cadena que corresponden al prefijo 0b que indica que es un número binario. Finalmente, utilizamos el método str.zfill(8) para rellenar con ceros a la izquierda hasta tener 8 dígitos. Por último, imprimimos el resultado con la función print().

# Pedir al usuario que ingrese un número entero
decimal = int(input("Introduce un número entero: "))

# Convertir a binario y rellenar con ceros a la izquierda hasta tener 8 dígitos
binario = f'{decimal:b}'.zfill(8)

# Imprimir el resultado
print(f"El número {decimal} en binario es {binario}.")

# Pedir al usuario que ingrese un número entero
decimal = int(input("Introduce un número entero: "))

# Convertir a binario
binario = f'{decimal:b}'

# Imprimir el resultado rellenando con ceros a la izquierda hasta tener 8 dígitos
print(f"El número {decimal} en binario es {binario:0>8}.")

#!/usr/bin/env python3

while True:

    try:
        #-- Pedir byte al usuario
        num = int(input("Introduce byte (0-255): "))

        #-- Imprimir en binario
        print(f"{num:08b}")

    except KeyboardInterrupt:
        print()
        print("Fin")
        break

#!/usr/bin/env python3

while True:

    try:
        #-- Pedir byte al usuario
        num = int(input("Introduce byte (0-255): "))


        #-- Pasar el numero a una cadena binaria de 8 bits
        cadbin = f"{num:08b}"

        #-- Sustituir el bit 0 por otro caracter
        cad = cadbin.replace('0','_').replace('1','▉')
        print(cad)

    except KeyboardInterrupt:
        print()
        print("Fin")
        break

#!/usr/bin/env python3

while True:

    try:
        #-- Pedir byte al usuario
        print()
        num = int(input("Introduce byte (0-255): "))


        #-- Pasar el numero a una cadena binaria de 8 bits
        cadbin = f"{num:08b}"

        #-- Sustituir el bit 0 por otro caracter
        cad = cadbin.replace('0','___').replace('1','▐█▌')

        #-- Imprimir
        print()
        print(" 0  1  2  3  4  5  6  7")
        print(cad)

    except KeyboardInterrupt:
        print()
        print("Fin")
        break

#!/usr/bin/env python3
 
#-- Cadenas para dibujar las lineas superiores e inferiores de un bit
#-- de la señal
#-- Hay 4 casos que dependen del bit actual y del siguiente
BIT_LINE = {

    #-- Linea superior
    "superior" : [
        '   ', #-- 0: Caso "00"
        '  ┌', #-- 1: Caso "01"
        '──┐', #-- 2: Caso "10"
        '───'  #-- 3: Caso "11"
    ],

    #-- Linea inferior
    "inferior": [
        '───', #-- 0: Caso "00"
        '──┘', #-- 1: Caso "01"
        '  └', #-- 2: Caso "10"
        '   ', #-- 3: Caso "11"
    ]
}

def print_wave(cadbin : str) -> None:
    """Imprimir la señal asociada a la cadena de bits"""

    #-- Duplicar el último bit (hay 9 bits)
    cadbin += cadbin[-1]

    #-- Cadena superior
    cadT = ""

    #-- Cadena inferior
    cadB = ""

    #-- Recorrer todos los bits para calcular las cadenas
    #-- superior e inferior
    #-- (hay 8 bits de datos a representar)
    for i in range(8):

        #-- Convertir el bit actual y el siguiente en un numero entero
        num = int(cadbin[i] + cadbin[i+1], 2)

        #-- Añadir las cadenas del bit actual
        cadT += BIT_LINE["superior"][num]
        cadB += BIT_LINE["inferior"][num]

    #-- Imprimir la señal
    print (cadT) #-- Parte superior
    print (cadB) #-- Parte inferior


#───────────────────────────────────────
# MAIN
#───────────────────────────────────────
while True:

    try:
        #-- Pedir byte al usuario
        print()
        num = int(input("Introduce byte (0-255): "))

    #-- Si se pulsa Ctrl-C --> Terminar
    except KeyboardInterrupt:
        print()
        print("Fin")
        break

    #-- Pasar el numero a una cadena binaria de 8 bits
    cadbin = f"{num:08b}"

    #-- Imprimir la señal
    print()
    print(" 0  1  2  3  4  5  6  7")

    print_wave(cadbin)

#!/usr/bin/env python3

num = 35
cad = "Hola"

#-- Imprimir las variables
print(f"Variable num: {num}, Variable cad: {cad}")

#-- Establecer una anchura máxima
print(f"Variable num: {num:10}, Variable cad: {cad:10}---")

#-- Mostrar el valor para depuración
print(f"Debug: {num=}, {cad=}")

#-- Imprimir numeros en base diferente
print(f"Num: Decial: {num:d}, Hexa: {num:x}, Binario: {num:b}----")

#-- Establecer tamaño maximo para numeros
print(f"Num: Decial: {num:5d}, Hexa: {num:4x}, Binario: {num:8b}----")

#-- Rellenar con 0s la izquierda
print(f"Num: Decial: {num:05d}, Hexa: {num:04x}, Binario: {num:08b}----")

#!/usr/bin/env python3

num = 35
cad = "Hola"

#-- Imprimir las variables
print(f"Variable num: {num}, Variable cad: {cad}")

#-- Establecer una anchura máxima
print(f"Variable num: {num:10}, Variable cad: {cad:10}---")

#-- Mostrar el valor para depuración
print(f"Debug: {num=}, {cad=}")

#-- Imprimir numeros en base diferente
print(f"Num: Decial: {num:d}, Hexa: {num:x}, Binario: {num:b}----")

#-- Establecer tamaño maximo para numeros
print(f"Num: Decial: {num:5d}, Hexa: {num:4x}, Binario: {num:8b}----")

#-- Rellenar con 0s la izquierda
print(f"Num: Decial: {num:05d}, Hexa: {num:04x}, Binario: {num:08b}----")

#!/usr/bin/env python3

FICHERO = "file2.txt"

#-- Ejemplo de apertura de un fichero de texto
#-- para escritura
with open("file2.txt", "w", encoding="utf-8") as f:
    f.write("Fichero de texto creado\n")
    f.write("Linea 1....\n")
    f.write("Linea 2...\n")
    f.write("Linea 3...\n")

print(f"Fichero {FICHERO} creado")

#!/usr/bin/env python3

FICHERO = "test1.bin"

#-- Ejemplo de apertura de un fichero binario
#-- para lectura
with open(FICHERO, "rb") as f:
    data = f.read()


print()
print(f"CONTENIDO FICHERO {FICHERO}:")
print(f"Tamaño: {len(data)} bytes")
print("──────────────────────")
print(data)
print("──────────────────────")

#!/usr/bin/env python3

FICHERO = "test1.bin"

#-- Ejemplo de apertura de un fichero binario
#-- para lectura
with open(FICHERO, "rb") as f:
    data = f.read()

#-- Pasar los bytes a cadenas de numeros hexadecimales
data_hex = [f"{byte:02x}" for byte in data]

print()
print(f"CONTENIDO FICHERO {FICHERO}:")
print(f"Tamaño: {len(data)} bytes")
print("──────────────────────")
print(" ".join(data_hex))
print("──────────────────────")

#!/usr/bin/env python3

FICHERO = "test2.bin"


#-- Cadena con los bytes a escribir
bytes = b"\x00\x01\x02\x03\xFF"

#-- Ejemplo de escritura de un fichero binario
with open(FICHERO, "wb") as f:
   f.write(bytes)

print(f"Fichero {FICHERO} creado")

#!/usr/bin/env python3

FICHERO = "test2.bin"


#-- Cadena con los bytes a escribir
bytes = bytes([0x00, 0x01, 0x02, 0x03, 0xFF])

#-- Ejemplo de escritura de un fichero binario
with open(FICHERO, "wb") as f:
   f.write(bytes)

print(f"Fichero {FICHERO} creado")

#!/usr/bin/env python3

import json

FICHERO1 =  "list.json"
FICHERO2 = "objeto.json"

#-- Ejemplo de lista
lista = ["holi", 2, 3, "vamos"]

#-- Ejemplo de diccionario (objeto)
objeto = {
    "nombre": "test",
    "id": 234
}

#-- Pasar a JSON
lista_json =  json.dumps(lista)
objeto_json = json.dumps(objeto)

#-- Imprimir sus correspondientes representaciones en JSON
print(lista_json)
print(objeto_json)

#-- Crear dos ficheros en JSON
with open(FICHERO1, "w", encoding="utf-8") as f:
    f.write(lista_json)

print(f"Creado fichero {FICHERO1}")

with open(FICHERO2, "w", encoding="utf-8") as f:
    f.write(objeto_json)

print(f"Creado fichero {FICHERO2}")

#!/usr/bin/env python3

import json

FICHERO1 =  "list.json"

#-- Leer directamente el fichero json
with open(FICHERO1, encoding='utf-8') as f:
    lista = json.load(f)

#-- Sabemos que el objeto es una lista...
#-- la iteramos e imprimimos su contenido
for e in lista:
    print(e)

#!/usr/bin/env python3

import json

#-- Fichero .ice a leer
ICE_FILE = "01-vacio.ice"

#-- Constantes asociadas a las propiedades del .ice
VERSION = "version"
DESIGN = "design"
BOARD = "board"

#-- Leer circuito. Accesible desde el objeto "top"
with open(ICE_FILE) as f:
    top = json.load(f)

#-- Imprimir información
print(f"Version: {top[VERSION]}")
print(f"Placa: {top[DESIGN][BOARD]}")

#!/usr/bin/env python3

import json

#-- Fichero .ice a leer
ICE_FILE = "02-info-1.ice"

#-- Constantes asociadas a las propiedades del .ice
VERSION = "version"
DESIGN = "design"
BOARD = "board"
GRAPH = "graph"
BLOCKS = "blocks"
WIRES = "wires"

#-- Leer circuito. Accesible desde el objeto "top"
with open(ICE_FILE) as f:
    top = json.load(f)

#-- Obtener el grafo del circuito
grafo = top[DESIGN][GRAPH]

#-- Obtener la lista de bloques y cables
bloques = grafo[BLOCKS]
cables = grafo[WIRES]


num_blocks = len(bloques)
num_wires = len(cables)

#-- Imprimir información
print(f"Version: {top[VERSION]}")
print(f"Placa: {top[DESIGN][BOARD]}")
print(f"Cables: {num_wires}")
print(f"Bloques: {num_blocks}")

#!/usr/bin/env python3

import json

#-- Fichero .ice a leer
ICE_FILE = "02-info-1.ice"

#-- Constantes asociadas a las propiedades del .ice
VERSION = "version"
DESIGN = "design"
BOARD = "board"
GRAPH = "graph"
BLOCKS = "blocks"
WIRES = "wires"
ID = "id"
TYPE = "type"

#-- Leer circuito. Accesible desde el objeto "top"
with open(ICE_FILE) as f:
    top = json.load(f)

#-- Obtener el grafo del circuito
grafo = top[DESIGN][GRAPH]

#-- Obtener la lista de bloques y cables
bloques = grafo[BLOCKS]
cables = grafo[WIRES]


num_blocks = len(bloques)
num_wires = len(cables)

#-- Imprimir información
print(f"Version: {top[VERSION]}")
print(f"Placa: {top[DESIGN][BOARD]}")
print(f"Cables: {num_wires}")
print(f"Bloques: {num_blocks}")

#-- Recorrer los bloques
for block in bloques:
    print(f"  * Bloque id: {block[ID]}")
    print(f"    * Tipo: {block[TYPE]}")
    print(f"    * Posicion: {block['position']}")
    print(f"    * Tamaño: {block['size']}")

#!/usr/bin/env python3

import json

#-- Constantes asociadas a las propiedades del .ice
VERSION = "version"
DESIGN = "design"
BOARD = "board"
GRAPH = "graph"
BLOCKS = "blocks"
WIRES = "wires"
ID = "id"
TYPE = "type"
SIZE = "size"

class Size:
    """Tamaño de los bloques de icestudio"""

    def __init__(self, width, height) -> None:
        """Crear un objeto Size a partir de numeros enteros"""
        self.width = width
        self.height = height

    def __init__(self, size: dict) -> None:
        """Crear un objeto Size a partir de un diccionario"""
        self.width = size['width']
        self.height = size['height']

    def obj(self) -> dict:
        """Devolver el objeto (diccionario) que contiene los datos"""
        
        return {
            "width" : self.width,
            "height": self.height
        }
    
    def __str__(self):
        """Devolver la cadena imprimible"""

        return f'Size({self.width}, {self.height})'


#-- Fichero .ice a leer
ICE_FILE = "02-info-1.ice"

#-- Leer circuito. Accesible desde el objeto "top"
with open(ICE_FILE) as f:
    top = json.load(f)

#-- Obtener tamaño del primer bloque
size = Size(top[DESIGN][GRAPH][BLOCKS][0][SIZE])

#-- Imprimir información
print(f"Version: {top[VERSION]}")
print(f"Placa: {top[DESIGN][BOARD]}")
print(f"Cables: {len(top[DESIGN][GRAPH][WIRES])}")
print(f"Bloques: {len(top[DESIGN][GRAPH][BLOCKS])}")
print(f"    * Tamaño: {size}")

#!/usr/bin/env python3

import json

#-- Constantes asociadas a las propiedades del .ice
VERSION = "version"
PACKAGE = "package"
DESIGN = "design"
DEPENDENCIES = "dependencies"
BOARD = "board"
GRAPH = "graph"
BLOCKS = "blocks"
WIRES = "wires"
ID = "id"
TYPE = "type"
SIZE = "size"

class Ice:
   
    def __init__(self, file: str=None) -> None:
        """Crear un objeto circuito a partir de un fichero .ice"""

        if file:
            #-- Leer el archivo .ice
            with open(file) as f:
                self._top = json.load(f)
        else:
            self._top = {
                "version": "1.2",
                "package": {
                    "name": "",
                    "version": "",
                    "description": "",
                    "author": "",
                    "image": ""
                },
                "design": {
                    "board": "alhambra-ii",
                    "graph": {
                        "blocks": [],
                        "wires": []
                    }
                },
                "dependencies": {}
            }

    @property
    def version(self):
        return self._top[VERSION]
    
    @property
    def package(self):
        return self._top[PACKAGE]
    
    @property
    def design(self):
        return self._top[DESIGN]
    
    @property
    def dependencies(self):
        return self._top[DEPENDENCIES]
    
    def __str__(self):

        cad = ""
        cad += f"Version: {ice.version}\n"
        cad += f"Placa: {ice.design[BOARD]}\n"
        cad += f"Cables: {len(ice.design[GRAPH][WIRES])}\n"
        cad += f"Bloques: {len(ice.design[GRAPH][BLOCKS])}\n"
        cad += f" * Tamaño: {ice.design[GRAPH][BLOCKS][0][SIZE]}\n"
        return cad


#-- Leer circuito
ice = Ice("02-info-1.ice")

#-- Imprimir información
print(ice)

#!/usr/bin/env python3

from Icestudio import Ice

#-- Leer circuito
top = Ice("02-info-1.ice")

#-- Imprimir información
print(top)

#!/usr/bin/env python3

import os

#-- Imprimir el directorio actual
print(f"Directorio actual: {os.getcwd()}")

#-- Subir de directorio
os.chdir("..")

#-- Imprimir el directorio actual
print(f"Directorio actual: {os.getcwd()}")

#-- Ejecutar un comando en la consola
ret = os.system('echo "hola"')

#-- Resultado
#-- Si ret es 0, todo ha ido bien...
if ret==0:
  print("OK!!")

#-- Ejecutamos un comando incorrecto
ret = os.system('fakeee')
if ret!=0:
  print("ERROR!!!!!")

#!/usr/bin/env python3

import shutil
shutil.copyfile('test/data1.txt', 'test/data2.txt')

shutil.move('test/data2.txt', 'test/data3.txt')

#!/usr/bin/env python3

import sys

#-- Imprimir la lista de argumentos pasados
print(sys.argv)

#!/usr/bin/env python3

import argparse

parser = argparse.ArgumentParser(
    prog='top',
    description='Show top lines from each file')
parser.add_argument('filenames', nargs='+')
parser.add_argument('-l', '--lines', type=int, default=10)
args = parser.parse_args()
print(args)
print(f"* Argumento lines: {args.lines}")  
print(f"* Argumento filenames: {args.filenames}")

#!/usr/bin/env python3

import sys

#-- Sacar por la consola estandar
sys.stdout.write("Salida normal\n")

#-- Sacar por la salida de error
sys.stderr.write('Error!!\n')

#-- Terminar
sys.exit()

#!/usr/bin/env python3

import subprocess

#-- Ejecutar "ls -l". La salida no se captura
result1 = subprocess.run(["ls", "-l"]) 

print(f"{result1.args=}")
print(f"{result1.returncode=}")
print(f"{result1.stdout=}")
print()

#-- Ejecutar "ls -l". Capturando la salida
result2 = subprocess.run(["ls", "-l"], capture_output=True)
print(f"{result2.args=}")
print(f"{result2.returncode=}")
print(f"{result2.stdout=}")
print()

#-- Esto tambien captura la salida
result3 = subprocess.run(["ls", "-l"], stdout=subprocess.PIPE)
print(f"{result3.args=}")
print(f"{result3.returncode=}")
print(f"{result3.stdout=}")
print(result3)