je suis incollable en python

Le 23 novembre 2025 à 23:16:14 :
L'animal ou en programmation ?

en python

Le 23 novembre 2025 à 23:14:51 :
venez tester mes skills

Est ce que tu saurais retrouver l'erreur?

Le 23 novembre 2025 à 23:17:09 :

Le 23 novembre 2025 à 23:14:51 :
venez tester mes skills

Est ce que tu saurais retrouver l'erreur?

t'as pas indenté le sticker

Le 23 novembre 2025 à 23:17:12 :
Quelle est la taille du plus long spécimen recensé ?

ddb

Le 23 novembre 2025 à 23:17:38 :

Le 23 novembre 2025 à 23:17:09 :

Le 23 novembre 2025 à 23:14:51 :
venez tester mes skills

Est ce que tu saurais retrouver l'erreur?

t'as pas indenté le sticker

Je confirme.
Tu as l'œil, et le bon!

Le 23 novembre 2025 à 23:17:47 :
combien d’espèces chez les pythons ?

la dernière stable c'est 3.14

import threading
import asyncio
import contextvars

cv = contextvars.ContextVar("cv", default=[])


class Tricky(type):
    def __new__(mcls, name, bases, ns, **kw):
        ns["attr"] = len(ns) + len(bases)
        cls = super().__new__(mcls, name, bases, ns)
        print("meta", cls.__name__, cls.attr)
        return cls


class Base(metaclass=Tricky):
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        print("init_subclass", cls.__name__, getattr(cls, "attr", None))


class A(Base):
    x = [i for i in range(3)]

    def __init__(self, n=cv.get()):
        n.append(id(self))
        self.n = n


class B(A, attr=42):
    async def run(self):
        await asyncio.sleep(0)
        print("B.run", self.n, cv.get())


async def main():
    cv.set(["main"])
    a = A()
    b = B()
    print("objects", id(a) == id(b), a.n is b.n)

    async def task():
        cv.set(["task"])
        await b.run()

    t = threading.Thread(target=lambda: asyncio.run(task()))
    t.start()

    await asyncio.sleep(0)
    await b.run()
    t.join()


asyncio.run(main())

liste tous les prints qui peuvent apparaître

def is_prime(n: int) -> bool:
    if n < 2:
        return False
    if n % 2 == 0:
        return n == 2
    d = 3
    while d * d <= n:
        if n % d == 0:
            return False
        d += 2
    return True


def goldbach_search():
    n = 4
    while True:
        # On ne regarde que les nombres pairs >= 4
        if n % 2 == 0:
            # Est-ce que n peut s'écrire comme somme de deux nombres premiers ?
            ok = False
            a = 2
            while a <= n:
                if is_prime(a) and is_prime(n - a):
                    ok = True
                    break
                a += 1

            # Si on ne trouve aucune décomposition, on a un contre-exemple :
            if not ok:
                print("Counterexample found:", n)
                return

        n += 2  # prochain nombre pair


if __name__ == "__main__":
    goldbach_search()

Est-ce que ce programme Python termine forcément un jour ?
Ou est-ce qu’il est possible qu’il ne termine jamais ?
Donne une réponse tranchée (il termine / il ne termine pas) avec une justification mathématique complète et intelligible. pas un truc pondu avec une ia

Le 23 novembre 2025 à 23:18:36 :
import threading import asyncio import contextvars cv = contextvars.ContextVar("cv", default=[]) class Tricky(type): def __new__(mcls, name, bases, ns, **kw): ns["attr"] = len(ns) + len(bases) cls = super().__new__(mcls, name, bases, ns) print("meta", cls.__name__, cls.attr) return cls class Base(metaclass=Tricky): def __init_subclass__(cls, **kw): super().__init_subclass__(**kw) print("init_subclass", cls.__name__, getattr(cls, "attr", None)) class A(Base): x = [i for i in range(3)] def __init__(self, n=cv.get()): n.append(id(self)) self.n = n class B(A, attr=42): async def run(self): await asyncio.sleep(0) print("B.run", self.n, cv.get()) async def main(): cv.set(["main"]) a = A() b = B() print("objects", id(a) == id(b), a.n is b.n) async def task(): cv.set(["task"]) await b.run() t = threading.Thread(target=lambda: asyncio.run(task())) t.start() await asyncio.sleep(0) await b.run() t.join() asyncio.run(main())

liste tous les prints qui peuvent apparaître

la flemme

Le 23 novembre 2025 à 23:20:50 :

Le 23 novembre 2025 à 23:18:36 :
import threading import asyncio import contextvars cv = contextvars.ContextVar("cv", default=[]) class Tricky(type): def __new__(mcls, name, bases, ns, **kw): ns["attr"] = len(ns) + len(bases) cls = super().__new__(mcls, name, bases, ns) print("meta", cls.__name__, cls.attr) return cls class Base(metaclass=Tricky): def __init_subclass__(cls, **kw): super().__init_subclass__(**kw) print("init_subclass", cls.__name__, getattr(cls, "attr", None)) class A(Base): x = [i for i in range(3)] def __init__(self, n=cv.get()): n.append(id(self)) self.n = n class B(A, attr=42): async def run(self): await asyncio.sleep(0) print("B.run", self.n, cv.get()) async def main(): cv.set(["main"]) a = A() b = B() print("objects", id(a) == id(b), a.n is b.n) async def task(): cv.set(["task"]) await b.run() t = threading.Thread(target=lambda: asyncio.run(task())) t.start() await asyncio.sleep(0) await b.run() t.join() asyncio.run(main())

liste tous les prints qui peuvent apparaître

la flemme

t'as un moyen simple de trouver mais pour ça faut savoir coder en python

Le 23 novembre 2025 à 23:19:20 :
def is_prime(n: int) -> bool: if n < 2: return False if n % 2 == 0: return n == 2 d = 3 while d * d <= n: if n % d == 0: return False d += 2 return True def goldbach_search(): n = 4 while True: # On ne regarde que les nombres pairs >= 4 if n % 2 == 0: # Est-ce que n peut s'écrire comme somme de deux nombres premiers ? ok = False a = 2 while a <= n: if is_prime(a) and is_prime(n - a): ok = True break a += 1 # Si on ne trouve aucune décomposition, on a un contre-exemple : if not ok: print("Counterexample found:", n) return n += 2 # prochain nombre pair if __name__ == "__main__": goldbach_search()

Est-ce que ce programme Python termine forcément un jour ?
Ou est-ce qu’il est possible qu’il ne termine jamais ?
Donne une réponse tranchée (il termine / il ne termine pas) avec une justification mathématique complète et intelligible. pas un truc pondu avec une ia

ca va overflow avant qu'on sache

Le 23 novembre 2025 à 23:21:20 :

Le 23 novembre 2025 à 23:20:50 :

Le 23 novembre 2025 à 23:18:36 :
import threading import asyncio import contextvars cv = contextvars.ContextVar("cv", default=[]) class Tricky(type): def __new__(mcls, name, bases, ns, **kw): ns["attr"] = len(ns) + len(bases) cls = super().__new__(mcls, name, bases, ns) print("meta", cls.__name__, cls.attr) return cls class Base(metaclass=Tricky): def __init_subclass__(cls, **kw): super().__init_subclass__(**kw) print("init_subclass", cls.__name__, getattr(cls, "attr", None)) class A(Base): x = [i for i in range(3)] def __init__(self, n=cv.get()): n.append(id(self)) self.n = n class B(A, attr=42): async def run(self): await asyncio.sleep(0) print("B.run", self.n, cv.get()) async def main(): cv.set(["main"]) a = A() b = B() print("objects", id(a) == id(b), a.n is b.n) async def task(): cv.set(["task"]) await b.run() t = threading.Thread(target=lambda: asyncio.run(task())) t.start() await asyncio.sleep(0) await b.run() t.join() asyncio.run(main())

liste tous les prints qui peuvent apparaître

la flemme

t'as un moyen simple de trouver mais pour ça faut savoir coder en python

yes mais j'ai une bonne grosse flemme

Le 23 novembre 2025 à 23:22:12 :

Le 23 novembre 2025 à 23:21:20 :

Le 23 novembre 2025 à 23:20:50 :

Le 23 novembre 2025 à 23:18:36 :
import threading import asyncio import contextvars cv = contextvars.ContextVar("cv", default=[]) class Tricky(type): def __new__(mcls, name, bases, ns, **kw): ns["attr"] = len(ns) + len(bases) cls = super().__new__(mcls, name, bases, ns) print("meta", cls.__name__, cls.attr) return cls class Base(metaclass=Tricky): def __init_subclass__(cls, **kw): super().__init_subclass__(**kw) print("init_subclass", cls.__name__, getattr(cls, "attr", None)) class A(Base): x = [i for i in range(3)] def __init__(self, n=cv.get()): n.append(id(self)) self.n = n class B(A, attr=42): async def run(self): await asyncio.sleep(0) print("B.run", self.n, cv.get()) async def main(): cv.set(["main"]) a = A() b = B() print("objects", id(a) == id(b), a.n is b.n) async def task(): cv.set(["task"]) await b.run() t = threading.Thread(target=lambda: asyncio.run(task())) t.start() await asyncio.sleep(0) await b.run() t.join() asyncio.run(main())

liste tous les prints qui peuvent apparaître

la flemme

t'as un moyen simple de trouver mais pour ça faut savoir coder en python

yes mais j'ai une bonne grosse flemme

alors pourquoi faire un topax sur ce theme ahii