Python类属性与全局变量

Question

I have defined an attribute(yYEAR) within a class and use a global variable(YEAR) to initialize it. When I called the method within the class it is updating the global variable, even if I didn't assign any value to it. Why is it happening like this?. Is the error is to do some with the incorrect location of definition of the class variable.

JAN = MAR =MAY =JUL =AUG= OCT =DEC=[0]*31
APR=JUN=SEP=NOV=[0]*30
FEB=[0]*28

YEAR = [JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC]

class load:
    yYEAR=YEAR
    def __init__(self, DURATION, LTYPE):
        self.DURATION=DURATION
        self.LTYPE= LTYPE


    def daily247(self):
        if self.LTYPE==1 :
            for month in range(len(self.yYEAR)):
                for day in range(len(self.yYEAR[month])):
                    self.yYEAR[month][day]= 1
            else:
                self.yYEAR= YEAR
        self.dispLoad()     

    def dispLoad(self):
        print(self.yYEAR[0])
        print(self.yYEAR[1])

event1= load(10,1)
event1.daily247() # Expected result ones in all nested elements in YEAR

event2= load(10,0)
event2.daily247()  # Expected result zeros in all nested elements in YEAR
print(YEAR[1])  # expected result is to have zeros for all elements

Answer 1

Your YEAR is a list type. Python's lists are mutable. Spelling it in all caps means that it should not be changed once set (a "constant"), but this is just a convention not enforced by Python at all.

If you want a separate copy that you can change instead of a reference to the global, do
yYEAR = YEAR[:] instead. Then the copy will belong to the class.

The [:] is slice notation that just copies the whole thing because you didn't specify bounds.
yYEAR = YEAR.copy() would also work, but the former is more conventional in the case of lists.

If you want a per-instance copy, set the attribute inside __init__ instead, like
self.yYEAR = YEAR[:] . Really, you could spell it as self.year . That would be more pythonic.

You can code your constants a little more defensively to protect yourself from accidental mutation by using an immutable tuple instead of a list. Then you would make your local list from it like yYear = [*YEAR] or if you're still using an old version of Python, yYear = list(YEAR) works too. But beware that immutable tuples can still contain mutable elements, so this doesn't completely enforce const correctness either.

---

Note also that syntax like APR=JUN=SEP=NOV=[0]*30 means that all four of those months will have a reference to the same list object.

Answer 2

The error was due to the python mutable lists as "glitch" mentioned. However the copying the list using [:] or .copy() does not work in this case as the original list is 2D.

Making a deepcopy of the 2D list fixed the problem.

import copy

and making a per instance deepcopy using deepcopy()

class load:
    def __init__(self, DURATION, LTYPE):
        self.DURATION=DURATION
        self.LTYPE= LTYPE
        self.yYEAR = copy.deepcopy(YEAR)