python 3.7 静态变量和内部变量的bug

# -*- coding=utf-8 -*-
import numpy as np
import os
import yaml
import logging
import re
import copy

from rich.console import Console
from rich.table import Table

from datetime import datetime
from common import common as c 
from functools import wraps
from runlog import log
from pathlib import Path
from threading import Thread, Lock

lock = Lock()

class vdict:
    v_columns_name = {}

    def __init__(self, name='', _list = []):
        self.__name = name 
        self.__list = _list
        self.__iter = 0
        self.__len = 0
        vdict.v_columns_name[self.__name] = []
        for i in range( len(_list)):
            vdict.v_columns_name[self.__name].insert(i, None) 

    def add_column(self, name, coltype):
        with lock:
            vdict.v_columns_name[self.__name].insert(self.__len, name+'|' +coltype)
            self.__list.insert(self.__len, None)
            self.__len = self.__len+1

    def set_column_name(self,i, name, coltype):
        with lock:
            vdict.v_columns_name[self.__name][i] = name+'|'+coltype


    def __next__(self):
        if self.__iter >=self.__len:
            raise StopIteration
        iteritem = self.__list[self.__iter]
        self.__iter += 1
        return iteritem

    def __iter__(self):
        self.__iter = 0
        return self

    def __len__(self):
        return self.__len

    def __getattr__(self, name):
        pass
    def __getitem__(self, key):
        return self.__list[key]
        
    def __setitem__(self, key, value):
        self.__list[key] = value

    def __getslice__(self, i, j):
        return self.__list[i:j]

    def __setslice__(self, i,j,value):
        self.__list[i:j] = value

    def __contains__(self, obj):
        return True if obj in self.list else False

    def print(self):
        table = Table(title = self.__name)
        for i in vdict.v_columns_name[self.__name]:
            table.add_column("None" if i is None else i , style="cyan", no_wrap=True)
        
        table.add_row(*[str(i) for i in self.__list])
        console = Console()
        console.print(table, justify="center")


c = vdict(name='c')
d = vdict(name='d')
e = vdict(name="e", _list=[])
f = vdict(name="f", _list=[])

c.add_column('c1', 'str')
c.add_column('c2', 'str')

e.add_column('e1', 'str')
e.add_column('e2', 'str')
f.add_column('f1', 'str')
f.add_column('f2', 'str')

c[0] = 1
c[1] = 2

c.print()
d.print()
e.print()
f.print()
e[0] = 1
e[1] = 2

f[0] = 3
f[1] = 4

e.print()
f.print()

我自定义了一个类，这个类的构造函数的参数在调用的过程中只传入少于定义参数个数的参数时，就会出现非静态变量 self.__list 在构造过程中变成了静态变量，注意 定义的vdict 类型的两个实例，c和d，这两个实例修改其中任何一个实例都会给另一个实例的内部成员变量带来修改。

可能使用 kwargs 这种方式可能会避免这个问题，但还没有完全改完，改完再看看结果。

class vdict:
    v_columns_name = {}

    def __init__(self, *args, **kwargs):
        print( args)
        print( kwargs)
        name = kwargs['name'] if 'name' in kwargs else ''
        _list = kwargs['_list'] if '_list' in kwargs else [] 
        self.__name = name 
        self.__list = _list
        self.__iter = 0
        self.__len = 0
        vdict.v_columns_name[self.__name] = []
        for i in range( len(_list)):
            vdict.v_columns_name[self.__name].insert(i, None) 

改完了，用这个可变参数就没有这个静态变量的问题了，所以使用python的这个参数可变的功能的时候务必使用这个可变参数，否则可能带来意想不到的问题。