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

最新推荐文章于 2023-11-18 20:26:46 发布

原创最新推荐文章于 2023-11-18 20:26:46 发布 · 511 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python #bug

学习同时被 3 个专栏收录

6 篇文章

订阅专栏

源代码

3 篇文章

订阅专栏

教程

2 篇文章

订阅专栏

本文探讨了在Python中自定义类时遇到的一个问题，即当构造函数只传入部分参数时，导致非静态变量变成静态变量。通过使用可变参数`*args`和`**kwargs`解决了这个问题，确保每个实例的成员变量独立。示例代码展示了如何创建和使用修复后的`vdict`类，并展示了如何添加列和设置值。最后，通过打印不同实例来验证修改不会相互影响。

# -*- 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的这个参数可变的功能的时候务必使用这个可变参数，否则可能带来意想不到的问题。