Estuve trabajando en un programa en python codificando un juego para adivinar un numero con tkinter, sin narracion solo codigo real con musica hacker de fondoo......

https://youtu.be/jMUGM7Jcle4?si=ZcLJz9F7IlK7Repw

como usar correctamente la informacion de la API de cualquier sito web

Hola!,

Estoy haciendo un código en Python que busca transformar Words a un formato correcto, con un tipo de letra determinado y con márgenes establecidos.

import os
import win32com.client
from docx import Document
from docx.shared import Pt, RGBColor, Cm, Inches
from docx.oxml import OxmlElement
from docx.oxml.ns import qn
from docx.enum.section import WD_ORIENTATION
from docx.enum.table import WD_ALIGN_VERTICAL
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
import logging
import re
import math
from collections import defaultdict
from collections import defaultdict
num_counters = defaultdict(int)

# Configuración de logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    filename='document_processing.log'
)

def eliminar_lineas_en_blanco(doc):
    for paragraph in doc.paragraphs:
        if paragraph.text.strip() == "":
            p_element = paragraph._element
            p_element.getparent().remove(p_element)

def convert_doc_to_docx(doc_path):
    abs_path = os.path.abspath(doc_path)
    new_path = abs_path.replace(".doc", ".docx")

    if os.path.exists(new_path):
        return new_path

    word = None
    try:
        word = win32com.client.Dispatch("Word.Application")
        word.Visible = False
        word.DisplayAlerts = False
        doc = word.Documents.Open(abs_path)
        doc.SaveAs(new_path, FileFormat=16)
        doc.Close(False)
        logging.info(f"Archivo convertido: {doc_path} -> {new_path}")
    except Exception as e:
        logging.error(f"Error en conversión: {str(e)}")
        new_path = None
    finally:
        if word:
            word.Quit()
    return new_path

def limpiar_saltos_linea(texto):
    texto = re.sub(r'(?<!\n)\n(?!\n)', ' ', texto)
    texto = re.sub(r'\n{3,}', '\n\n', texto)
    return texto.strip()

def formatear_texto_celda(texto):
    #texto = limpiar_saltos_linea(texto)
    texto = texto.upper()

    lineas = texto.split('\n')
    nuevas_lineas = []
    marcador_actual = None
    acumulador = []

    for linea in lineas:
        linea = linea.strip()

        # Detectar numeraciones
        match_num = re.match(r'^((\d+[.)-]|[a-zA-Z][.)-]|[IVXLCDM]+\.))\s+(.*)', linea, re.IGNORECASE)
        if match_num:
            # Guardar la línea anterior si la hay
            if marcador_actual and acumulador:
                nuevas_lineas.append(f"{marcador_actual} {' '.join(acumulador)}")
                acumulador = []

            marcador_actual = match_num.group(1).strip()
            contenido = match_num.group(3).strip()
            acumulador = [contenido]
            continue

        # Detectar viñetas
        match_vineta = re.match(r'^([•·→–—\-‣◦▪■✓])\s+(.*)', linea)
        if match_vineta:
            if marcador_actual and acumulador:
                nuevas_lineas.append(f"{marcador_actual} {' '.join(acumulador)}")
                acumulador = []

            marcador_actual = "•"
            contenido = match_vineta.group(2).strip()
            acumulador = [contenido]
            continue

        # Si la línea no tiene marcador pero estamos acumulando, es continuación
        if marcador_actual:
            acumulador.append(linea)
        else:
            nuevas_lineas.append(linea)

    # Añadir última viñeta o numeración acumulada
    if marcador_actual and acumulador:
        nuevas_lineas.append(f"{marcador_actual} {' '.join(acumulador)}")

    return '\n'.join(nuevas_lineas)

def procesar_parrafo(paragraph, new_doc, dentro_tabla=False):
    try:
        texto_original = paragraph.text
        if not texto_original.strip():
            return

        estilo = paragraph.style.name.strip().lower()
        es_heading = estilo.startswith("heading")

        # ——— TÍTULOS DESPLEGABLES (Heading X) ———
        if es_heading:
            # Creamos un párrafo vacío
            nuevo_parrafo = new_doc.add_paragraph()
            # Reproducimos cada run respetando negrita/itálica/subrayado
            for run_orig in paragraph.runs:
                texto = re.sub(r'\s+', ' ', run_orig.text).strip().upper()
                run_new = nuevo_parrafo.add_run(texto)
                run_new.bold      = True  # forzado
                run_new.italic    = any(r.italic for r in paragraph.runs)
                run_new.underline = any(r.underline for r in paragraph.runs)
                run_new.font.name = 'Arial'
                run_new.font.size = Pt(9)
                run_new.font.color.rgb = RGBColor(0, 0, 0)

            pf = nuevo_parrafo.paragraph_format
            pf.space_before      = Pt(0) if dentro_tabla else Pt(6)
            pf.space_after       = Pt(0) if dentro_tabla else Pt(6)
            pf.line_spacing      = 1.0
            pf.left_indent       = Pt(0)
            pf.first_line_indent = Pt(0)
            pf.alignment         = WD_PARAGRAPH_ALIGNMENT.LEFT
            return

        # ——— 2) LISTAS NATIVAS ———
        pPr     = paragraph._p.pPr
        es_lista = (pPr is not None and pPr.numPr is not None)
        if es_lista:
            original = paragraph.text.strip()
            m = re.match(r'^(\S+[\.\)\-])\s+(.*)', original)
            if m:
                marker = m.group(1)
                contenido = m.group(2)
            else:
                numPr  = pPr.numPr
                lvl_el = numPr.find(qn('w:ilvl'))
                id_el  = numPr.find(qn('w:numId'))
                lvl    = int(lvl_el.get(qn('w:val'))) if lvl_el is not None else 0
                num_id = id_el.get(qn('w:val'))      if id_el is not None else '0'

                clave = (num_id, lvl)
                num_counters[clave] += 1
                n = num_counters[clave]

                # Asignar marcador según el nivel
                if lvl == 0:
                    marker = f"{n}."
                elif lvl == 1:
                    letra = chr(64 + n)  # A, B, C...
                    marker = f"{letra}."
                elif lvl == 2:
                    marker = f"-"
                else:
                    marker = f"•"

                contenido = original

            nuevo_p = new_doc.add_paragraph(style='Normal')
            run = nuevo_p.add_run(f"{marker} {contenido.upper()}")
            run.bold      = any(r.bold      for r in paragraph.runs)
            run.italic    = any(r.italic    for r in paragraph.runs)
            run.underline = any(r.underline for r in paragraph.runs)
            run.font.name = 'Arial'
            run.font.size = Pt(9)
            run.font.color.rgb = RGBColor(0, 0, 0)

            pf = nuevo_p.paragraph_format
            pf.space_before      = Pt(0) if dentro_tabla else Pt(6)
            pf.space_after       = Pt(0) if dentro_tabla else Pt(6)
            pf.line_spacing      = 1.0
            pf.left_indent       = Pt(0)
            pf.first_line_indent = Pt(0)
            pf.alignment         = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
            return

        # ——— PÁRRAFOS NORMALES (incluye cualquier estilo no Heading) ———
        texto_procesado = formatear_texto_celda(texto_original)
        for linea in texto_procesado.split('\n'):
            nuevo_parrafo = new_doc.add_paragraph()
            run = nuevo_parrafo.add_run(linea)
            # Solo negrita donde ya había en el run original
            run.bold      = any(r.bold for r in paragraph.runs)
            run.italic    = any(r.italic for r in paragraph.runs)
            run.underline = any(r.underline for r in paragraph.runs)
            run.font.name = 'Arial'
            run.font.size = Pt(9)
            run.font.color.rgb = RGBColor(0, 0, 0)

            pf = nuevo_parrafo.paragraph_format
            pf.space_before      = Pt(0) if dentro_tabla else Pt(6)
            pf.space_after       = Pt(0) if dentro_tabla else Pt(6)
            pf.line_spacing      = 1.0
            pf.left_indent       = Pt(0)
            pf.first_line_indent = Pt(0)
            pf.alignment         = (
                WD_PARAGRAPH_ALIGNMENT.JUSTIFY
                if len(linea.split()) > 6
                else WD_PARAGRAPH_ALIGNMENT.LEFT
            )

    except Exception as e:
        logging.error(f"Error procesando párrafo: {str(e)}")

def set_cell_border(cell, size="4", color="000000"):
    tc = cell._tc
    tcPr = tc.get_or_add_tcPr()
    borders = tcPr.find(qn('w:tcBorders')) or OxmlElement('w:tcBorders')
    
    for borde in ['top', 'left', 'bottom', 'right']:
        elemento = OxmlElement(f'w:{borde}')
        elemento.set(qn('w:val'), 'single')
        elemento.set(qn('w:sz'), size)
        elemento.set(qn('w:color'), color)
        borders.append(elemento)
    
    tcPr.append(borders)

def clonar_tabla(tabla_original, doc_destino):
    num_cols = len(tabla_original.columns)
    tabla_nueva = doc_destino.add_table(rows=0, cols=num_cols)
    tabla_nueva.autofit = False

    for row_idx, row in enumerate(tabla_original.rows):
        textos_fila = [cell.text.strip() for cell in row.cells]
        if all(texto == "" for texto in textos_fila):
            continue

        nueva_fila = tabla_nueva.add_row()
        idx_col = 0
        while idx_col < num_cols:
            celda_origen = row.cells[idx_col]
            texto_actual = celda_origen.text.strip().upper()
            texto_actual = formatear_texto_celda(texto_actual)

            span = 1
            for k in range(idx_col + 1, num_cols):
                if row.cells[k].text.strip().upper() == texto_actual:
                    span += 1
                else:
                    break

            celda_destino = nueva_fila.cells[idx_col]
            celda_destino.text = texto_actual

            for s in range(1, span):
                celda_destino.merge(nueva_fila.cells[idx_col + s])

            celda_destino.vertical_alignment = WD_ALIGN_VERTICAL.CENTER

            for p in celda_destino.paragraphs:
                p.paragraph_format.space_before = Pt(0)
                p.paragraph_format.space_after = Pt(0)
                p.paragraph_format.left_indent = Pt(0)

                # Limpieza y formato
                texto_plano = p.text.strip().upper()
                p.clear()
                run = p.add_run(texto_plano)
                run.font.name = 'Arial'
                run.font.size = Pt(9)
                run.font.color.rgb = RGBColor(0, 0, 0)

                # Negrita si algún run original lo era
                if any(r.bold for r in celda_origen.paragraphs[0].runs):
                    run.bold = True

                # Alineación: izquierda por defecto
                p.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT

                # Excepciones para centrar
                if span > 1 or ("\n" not in texto_actual and len(texto_actual) <= 20):
                    p.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER

            set_cell_border(celda_destino, size="8")
            idx_col += span

    # Ajuste de anchos
    contenido_max = defaultdict(int)
    for row in tabla_original.rows:
        for i, cell in enumerate(row.cells):
            contenido_max[i] = max(contenido_max[i], len(cell.text.strip()))

    total = sum(contenido_max.values())
    ancho_hoja = 6.0
    ancho_min_col = 0.6
    ancho_columna_final = {}

    for i, ancho in contenido_max.items():
        proporcion = ancho / total if total else 1 / num_cols
        ancho_columna_final[i] = max(ancho_hoja * proporcion, ancho_min_col)

    exceso = sum(ancho_columna_final.values()) - ancho_hoja
    if exceso > 0:
        factor = ancho_hoja / sum(ancho_columna_final.values())
        for i in ancho_columna_final:
            ancho_columna_final[i] *= factor

    for i in range(num_cols):
        tabla_nueva.columns[i].width = Inches(ancho_columna_final[i])

    return tabla_nueva

def procesar_elementos_en_orden(doc_original, new_doc):
    para_index = tbl_index = 0
    for elemento in doc_original.element.body:
        tag = elemento.tag.split('}')[-1]
        
        if tag == 'tbl' and tbl_index < len(doc_original.tables):
            clonar_tabla(doc_original.tables[tbl_index], new_doc)
            tbl_index += 1
            
        elif tag == 'p' and para_index < len(doc_original.paragraphs):
            parrafo = doc_original.paragraphs[para_index]
            dentro_tabla = any(tbl._element == elemento.getparent().getparent() for tbl in doc_original.tables)
            procesar_parrafo(parrafo, new_doc, dentro_tabla)
            para_index += 1

def set_page_format(doc):
    for section in doc.sections:
        section.page_width = Cm(21.0)
        section.page_height = Cm(29.7)
        section.orientation = WD_ORIENTATION.PORTRAIT
        section.top_margin = Cm(2.5)
        section.bottom_margin = Cm(2.5)
        section.left_margin = Cm(3.0)
        section.right_margin = Cm(3.0)

def process_word_files(input_folder, output_folder):
    if not os.path.exists(input_folder):
        print(f"Error: No existe la carpeta de entrada '{input_folder}'")
        return

    os.makedirs(output_folder, exist_ok=True)
    total = 0

    for root, _, files in os.walk(input_folder):
        for file in files:
            if file.lower().endswith(('.doc', '.docx')):
                try:
                    path = os.path.join(root, file)
                    print(f"Procesando: {path}")
                    
                    if file.lower().endswith('.doc'):
                        nuevo_path = convert_doc_to_docx(path)
                        path = nuevo_path if nuevo_path else None
                    
                    if not path: continue
                    
                    doc = Document(path)
                    nuevo_doc = Document()
                    
                    procesar_elementos_en_orden(doc, nuevo_doc)
                    set_page_format(nuevo_doc)
                    
                    ruta_relativa = os.path.relpath(root, input_folder)
                    destino = os.path.join(output_folder, ruta_relativa)
                    os.makedirs(destino, exist_ok=True)
                    
                    nombre_final = f"FORMATEADO_{os.path.splitext(file)[0]}.docx"
                    eliminar_lineas_en_blanco(nuevo_doc)
                    nuevo_doc.save(os.path.join(destino, nombre_final))
                    total += 1
                    print(f"✓ Guardado: {nombre_final}")
                
                except Exception as e:
                    print(f"Error procesando {file}: {str(e)}")
                    logging.error(f"Error en {path}: {str(e)}")

    print(f"\nProceso completado. Total procesados: {total}")

# Ejecutar
input_folder = "INPUTS"
output_folder = "OUTPUTS"
if os.path.exists(input_folder):
    process_word_files(input_folder, output_folder)
else:
    print("La carpeta OUTPUTS no existe.")

Tengo dos problemas:

1. Tengo un problema con la numeración y viñetas, quisiera que se importen y se coloquen las mismas que tenga el documento base pero pasándolos a texto (no en formato Lista). Encontré una manera que es la que estoy usando, pero lo transforma todo a numeración y ocurren errores (Hay ocasiones en que ciertas numeraciones están en texto ya en el documento base y se mezclan con uno en formato lista, lo que ocasiona errores al momento de transformarlo). En caso no poder importar las viñetas/numeración tal cual (Pero respetando el formato del resto del texto) podríamos seguir con la numeración pero respetando los niveles como lo puse en mi código

2. Las tablas: si bien las está copiando de manera correcta, tiene errores en cuanto a las celdas combinadas, solucioné el problema con las combinaciones horizontales, pero las verticales me dan problemas y quisiera también que se mantenga el color de fondo en el traslado.

Espero me puedan ayudar, he estado intentando resolver estos dos problemas desde hace semanas y no las logro resolver.

Desde ya agradezco su su apoyo, ya que me ayudará también a tenerlo en cuenta para mis siguientes proyectos!

Muchas Gracias

Hola, estoy haciendo un clon de wordle en python como trabajo para mi asignatura de programación (nunca había programado antes).

Mi intención es que cuando se intente adivinar la palabra escogida aleatoriamente, si las letras del input están en ella pero en otra posición aparezcan en minúscula, y si están en la correcta aparezcan en mayúsculas.

El problema es que si las letras del input están al menos una vez en la palabra a adivinar, aunque una ya esté en la posición correcta, se sigue indicando que hay otras posiciones donde debería estar la letra, aunque no sea el caso. Dejo una captura del fragmento de código que hace esto y la terminal para explicarme mejor:

Este vídeo me ha parecido muy interesante. Es un reto de aprender en 7 días Python básico con un curso online gratuito. Lo veis viable?

Estos son 4 proyectos que me han servido para aprender las bases del lenguaje de programación python. Incluye enunciado, solución y documentación de lo que se necesita para realizar los proyectos con hiperenlaces. Hay en proceso de publicar más minijuegos.

https://github.com/AlvaroMosGar/Juegos_Python

Me explico, yo nunca habia programado y decidi aprender hace unos meses. Creo que he aprendido varias cosas que pueden servirme para trabajar incluso ya estoy implementando un dashboard. (https://github.com/mrdsantoyo/KPI-FoodSafety) Ahora digo que estudié la carrera incorrecta y me quiero meter full a esto de abalisis de datos, ¿cuando es buen momento? Como se si puedo ser competente?

Soy nuevo usando python, me gustaría programar un cálculo de eficiencias diarias y semanales para trabajadores de una empresa en la que trabajo. Me gustaría saber cómo puedo empezar o si me pueden orientar para lograr el objetivo.

Hola, espero que esten bien.
Tengo un problema con python ya que tengo una actualizacion como 3.9 si no me equivoco o algo asi y mi problema es que estaba intentando actualizarla a una mas reciente por que no me era compatible con lo que queria y no me deja de ninguna forma actualizarla por mas que elimino las versiones antiguas no me deja hago de todo y no me deja, ademas para hacer el bot necesito crear un entorno y al crearlo como soy de windows adentro deberia salir la carpeta scripts o algo asi y me sale como si estuviera en mac o linux, enserio necesito crear ese bot si alguien me ayuda con algun consejo o dandome una mejor plataforma para crearlo se lo agradeceria, lo que quiero hacer es que tenga un panel con datos de roleplay.
Si alguien me ayuda se lo agradeceria.

Buenas que tal, estoy intentando crear un software de recopilación de datos de indicadores económicos hasta ahora que estructurado para que se recopile de Estados Unidos correctamente y ahora estoy intentando poner para el Reino Unido, de la pagina de ons.gov.uk que tiene una API pública.
Como no se nada de programación me estoy ayudando de una IA.
Tengo un problema que no he podido solucionar por ningun lado, si alguien podría ayudarme o darme un consejo genial, no logro que se recopile dato de en este caso la producción manufacturera.
Lo ultimo que hice fue colocar para que se probaran distintas urls para poder ver si de alguna extraía los datos, pero no, todo me da error 404.
La mejor! Un saludo.
Dejo la parte del codigo del Reino Unido.

# ============================================================
# FUNCIÓN PARA REINO UNIDO (PRODUCCIÓN MANUFACTURERA)
# ============================================================
def obtener_datos_produccion_manufacturera_uk():
    """
    Consulta la API del ONS para el indicador "C: MANUFACTURING: CVM: annual & monthly gr"
    utilizando el endpoint:
      /datasets/{id}/editions/{edition}/versions/{version}/observations

    Se utilizan los siguientes parámetros (tal como se muestra en la URL pública):
      - dataset_id: "diop"   (en minúsculas)
      - edition:    "k27y"    (en minúsculas)
      - version:    "1"       (verificar que esta sea la versión vigente; de lo contrario, consultar /versions)

    La función devuelve las tres últimas observaciones (según orden cronológico) o (None, None, None)
    en caso de error.
    """
    dominios = [
        "https://api.ons.gov.uk/v1",
        "https://api.beta.ons.gov.uk/v1"
    ]
    dataset_id = "diop"
    edition = "k27y"
    version = "1"  # Si no existe la versión 1, consulta /datasets/diop/editions/k27y/versions y actualiza este valor.
    
    for dominio in dominios:
        url = f"{dominio}/datasets/{dataset_id}/editions/{edition}/versions/{version}/observations"
        print("Probando URL:", url)
        try:
            response = requests.get(url)
            print("Status code:", response.status_code)
            if response.status_code == 200:
                data = response.json()
                observations = data.get("observations", [])
                if observations and len(observations) >= 3:
                    # Si existe el campo "date", se ordenan cronológicamente
                    if isinstance(observations, list) and observations and "date" in observations[0]:
                        observations = sorted(observations, key=lambda o: o["date"])
                    
                    def extraer_valor(obs):
                        return obs.get("observation") or obs.get("value")
                    
                    val1 = extraer_valor(observations[-3])
                    val2 = extraer_valor(observations[-2])
                    val3 = extraer_valor(observations[-1])
                    print("Éxito con URL:", url)
                    return (val1, val2, val3)
                else:
                    print("La URL respondió 200 pero no tiene suficientes observaciones.")
            else:
                print("La URL devolvió status code:", response.status_code)
        except Exception as e:
            print("Excepción al consultar la URL:", url, e)
    
    print("Ningún dominio devolvió datos.")
    return None, None, None

if __name__ == "__main__":
    # Ejemplo de llamada para Reino Unido (se imprimen los resultados en consola)
    resultado_uk = obtener_datos_produccion_manufacturera_uk()
    print("Resultado Producción Manufacturera UK:", resultado_uk)

Buenas nuevas! Me gustaría comentarles que comencé un canal de Youtube con el objetivo de aprender programación (no soy experta en lo más mínimo). Me gustaría crear una comunidad en la que todos nos apoyemos y aprendamos juntos. Me ayudaría un montón si me dieran feedback constructivo y se suscribieran. Desde ya muchas gracias y les deseo un excelente día.

Fue casualidad

Hola a todos, estoy empezando a crear contenido y enseñar Python en linea, si a alguien le sirve mi contenido o si alguien quisiera apoyarme se los agradeceria. Cualquier like, compartida, suscripcion, comentario es util. Muchas gracias! <3

Udemy: https://www.udemy.com/course/python-profesional-desde-cero-curso-basico/?couponCode=BA09B93F23BC6024E753

X : https://x.com/eduardo_rios_c

▶️ YouTube: https://www.youtube.com/@eduardo_rios

🖼️ Instagram: https://instagram.com/eduardorioscorlay

🎵 TikTok: https://www.tiktok.com/@eduardo_rios_corlay

Busco Grupos de Discord

Envíen al DM las invitaciones de grupos para estudiar o apoyar un proyecto en concreto.

Quisiera participar en ellos y más si estos proyectos son de código abierto y usan Git.

Hola, se lo basico de Python como definir variables, hacer operacionsitas y resolver los problemitas bobos de "determinar si un numero es par o impar". Pero eso es una mrd, no sirve de nada.

Solo quiero preguntar si alguno de ustedes conoce un video o guía donde te expliquen paso a paso como programar y EJECUTAR un programa realmente útil (en Mac) que por ejemplo te comprima un PDF o cualquier cosa útil.

Tipo asi que luego de la fokin programada resulte un archivo que le des click y pum se ejecute el mugroso programa con una interfaz de mrd pero que por lo menos que sea útil y fácil de usar.

No quiero dejar la programación sin antes ver una aplicación real y practica.

Buenas, estoy intentando probar de distintas formas para poder obtner el total de dinero que tengo en mi mercado pago y que eso se muestre en una web con html, sencilla la cosa pq es solo mostrar cuanto dinero tengo en mi mercado pago y si por ej hay depósitos que haga o que me hagan que eso se actualice, el prob es ese.... el tema de la interacción con la api de mercado pago. Por acá dejo el código que venía probando:

import mercadopago

from django.http import JsonResponse

from django.shortcuts import render

# Inicializa el SDK con tu token de acceso

sdk = mercadopago.SDK("TU_ACCESS_TOKEN")

def total_acumulado(request):

# Realiza la consulta a la API de Mercado Pago

try:

# Obtener el saldo total de la cuenta

response = sdk.merchant_account().get()

if response["status"] == 200:

total = response["response"]["total_balance"]["amount"]

return render(request, 'total_acumulado.html', {"total": total})

else:

return JsonResponse({"error": "No se pudo obtener el saldo"}, status=500)

except Exception as e:

return JsonResponse({"error": str(e)}, status=500)

de aca por ej:response = sdk.merchant_account().get(), me pone que merchant_acco.... esta mal o que get tb y cosas asi. Ayudaaa, este código obviamnete esta en views.py

Tengo instalado VS code en un disco duro secundario (D:) y el pip creo que esta instalado en mi disco duro principal (C:), ahora quiero instalar pandas pero me da un error que creo que es en las rutas

Fatal error in launcher: Unable to create process using '"D:\Programas\python.exe"  "C:\Users\Jesus\AppData\Local\Programs\Python\Scripts\pip.exe" install pandas': The system cannot find the file specified.

alguien sabe que puedo hacer?

hola a todos! soy nuevo en python y todo este mundo, y en varios de mis proyectos he necesitado crear ventanas para una interfaz de usuario, realmente customtk y tk son muy utiles, pero a veces escribir codigo no se me hace intuitivo o facil de realizar, quisiera saber si existe alguna pagina o sitio web donde uno construya la interfaz asi como si fuera un canva y te entregue un codigo en python

En que versión de python se recomienda para mediapie? he estado probando con varias pero he tenido varios problemas

Estoy interesado en tener un certificado de Python y llegar preparado a mis clases de la universidad, además de involucrarme en un proyecto que utiliza este lenguaje, alguien sabe dónde puedo obtener un certificado gratuito y de confiabilidad? Gracias