Bonjour. Python gère les grands nombres effectivement mais c'est une autre histoire pour les floatant. Je vois donc deux possibilités pour "l'erreur":
La division par 10 ou tout simplement la commande "int" qui force l'utilisation d'entier ("pas long") car le type long est peut-être nommé autrement.
Une possibilité à tester: utilise modulo 10 (%10) pour avoir le dernier chiffre. Ensuite tu le retranches puis tu divises par 10.
Dernière remarque mais c'est peut être hors sujet sur la façon de programmer.
Converti l'entier en chaîne de caractères et parcours cette chaîne.

salut

en python le "double diviser" ne fait-il pas une division entière tout simplement  :

EX : 23 // 10 renvoie directement 2

Merci jarod128 et carpediem pour vos retours.
En combinant vos deux réponses, j'ai pu obtenir un programme qui fonctionne avec des nombres très longs, je vous le livre ci-dessous.
Et pour répondre au commentaire final, de jarod128, effectivement c'aurait été bien plus rapide avec un balayage de la chaîne, mais la méthode était imposée dans un exercice, et je m'y suis tenu

#somme des chiffres d'un nombre
n=eval(input("Entrez un entier positif ou nul : "))
q=n
S=0
while q>0:
     q0=q
     r1=q%10
     q1=(q-r1)//10
     S=S+r1
     q=q1
     print(q0,q1,r1,S)
print("Somme des chiffres = ",S)

sans utiliser la fonction mod mais uniquement les quatre opérations :

#somme des chiffres d'un nombre
n = eval(input("Entrez un entier positif ou nul : "))
q = n
S = 0
while q > 0 :
     q0 = q // 10
     r = q - 10 * q0
     q = q0
     S = S + r
     print(q0,q1,r1,S)     pourquoi cette ligne d'ailleurs ?
print("Somme des chiffres = ",S)

Effectivement, ça marche aussi, merci !

salut,
version fonctionnelle

def SommeChiffres(n):
    s=0
    while n!=0:
        s=s+n%10
        n=n//10
    return s

Je viens après la bataille mais je trouve l'idée de jarod128 excellente.

n=input("Entrez un entier positif ou nul : ")
s=0
for c in n :
	s+=eval(c)
print("Somme des chiffres = "s)

Je ne pratique pas du tout Python, mais on m'a appris une chose :  en Python, il faut à tout prix éviter les boucles.

Et donc, quelque chose comme ça :

n=input("Entrez un entier positif ou nul : ")
ll = list(n.strip())
print(ll)
l2 = list(map(int,ll))
print(l2)
i = sum(l2)
print(i)

Python est un langage interprété et non compilé.
Ca veut dire qu'au moment de l'exécution, chaque instruction est traduite en langage machine, puis exécutée.

Et la traduction est plus longue que l'exécution.

Une instruction sum() ...  il y a une seule traduction.

Dans une boucle, à chaque étape, il faut traduire la ligne for i in ...
et il faut traduire la ligne total = total+ eval(c)

En gros, si on traite une chaine de 10 caractères, le traitement par une boucle devrait être 20 fois plus lent que le traitement par l'instruction sum().

Je ne suis pas un pro, et donc j'ai voulu vérifier, pour éviter de dire n'importe quoi.
Et effectivement, c'est assez probant :

import datetime
time0 =  datetime.datetime.now()

for i in range(10):
    ch0 = '123'*1000
    ssum=0
    for c in ch0:
        ssum += eval(c)
time1 =  datetime.datetime.now()

for i in range(10):
    ch0 = '123'*1000
    ll = list(ch0.strip())
    l2 = list(map(int,ll))
    i = sum(l2)
time2 =  datetime.datetime.now()

ch0 = '123'*10000
ll = list(ch0.strip())
l2 = list(map(int,ll))
i = sum(l2)
time3 =  datetime.datetime.now()

print("time0="+ str(time0))
print("time1="+ str(time1))
print("time2="+ str(time2))
print("time3="+ str(time3))  

time0=2021-08-11 08:20:46.826159
time1=2021-08-11 08:20:47.692497
time2=2021-08-11 08:20:47.775110
time3=2021-08-11 08:20:47.782303