Salut,
 
je suis tombé sur un truc sur lequel j'ai mis pas mal de temps pour voir d'où venait le problème. Voici un exemple simple :
 - un module, nommé module_test pour l'occasion

class table:
    
    name = None
    attr = []
    
    def __init__(self, name):
        self.name = name
    
    def attr_add(self, att):
        self.attr.append(att)

 - et un petit jeu de test unitaire (noté la subtile inversion des noms des méthodes dans la classe TableTest ) :

#!/usr/bin/env python
 
import unittest
import module_test
 
VERBOSITY = 2
 
class TableTest(unittest.TestCase):
    
    def test2(self):
        t = module_test.table('t_test')
        
        self.assertEqual(t.name, 't_test')
        self.assertEqual(t.attr, [])
    
    def test1(self):
        t = module_test.table('t_test')
        att = 'gni'
        t.attr_add(att)
        
        self.assertEqual(len(t.attr), 1)
        self.assertEqual(t.attr[0], att)
 
 
 
def suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(TableTest))
    return suite
 
 
if __name__ == "__main__":
    unittest.TextTestRunner(verbosity=VERBOSITY).run(suite())

 
Bref, rien de transcendant
Le problème est :

 
Pourquoi je récupère cette valeur d'attribut pour table.attr ?
Bien sur, si je rajoute un self.attr = [] dans le constructeur de table, le problème est résolu, mais j'aimerais comprendre ce qui se passe ...

Parce que attr est un attribut membre de la classe, donc il est construit à la création de la classe (== au parsing du fichier contenant la classe) et détruit à la destruction de l'objet classe (pas de l'instance de la classe, donc à la toute fin du script)
 
Donc ça se passe comme ça:
1. Le "module_test" est importé
2. L'objet "table" (a) (la classe donc) est crée
    a. table.name est instancé
    b. table.attr est instancé
3. L'objet TableTest est créé
4. Lancement des tests
6. Lancement du premier test
    a. Une instance de "table" est créée
    b. un élément est ajouté à table.attr, donc à un attribut de classe
    c. l'instance de "table" est détruite
7. Lancement du 2e test
    a. Une instance de "table" est créée
    b. Un test est effectué sur table.attr, donc l'attribut de classe
8. Les tests se terminent
9. L'objet (classe) TableTest est détruit
10. L'objet (classe) table est détruit, son attribut attr avec
11. Le script se termine
 
Quand tu effectues un accès sur un attribut d'une instance, Python recherche tout d'abord les attributs de l'instance, puis les attributs de la classe de l'instance
 
a. Ce nom va complètement à l'encontre de la PEP8 au passage, et tu devrais hériter d'object, toujours hériter d'object ou d'une classe en héritant déjà

Ok, je voyais ça un peu comme ça. Donc, à priori, je peux laisser tomber la déclaration de mes attributs ici, et déplacer leur initialisation dans le constructeur ? (à part si je veux précisément ce comportement, ou si je leur donne une valeur dans le constructeur, comme pour name)

Tout a fait, j'en ai déjà fait les frais, j'ai juste fais un test rapide pour voir si j'arrivais à reproduire ce truc

Ben oui, si tu veux un attribut d'instance tu le définit en tant qu'attribut d'instance quoi

Ça roule
 
Merci

J'avouerais par contre qu'au début je me suis également fait avoir une ou deux fois par le fait qu'on déclare un attribut de classe de cette manière

On va dire que c'est des "restes" de C++ ou de C#