标签: class-variables

根据Reek的说法,创建一个类变量被认为是"代码味道".这背后的解释是什么？

有没有办法防止或改变Python中类变量的访问,因为可以通过覆盖__setattr__实例变量？

请注意,此问题是错误的,实际上是指实例变量,而不是类变量.

在阅读关于(明显的)死亡陷阱的多篇帖子的基础上__slots__,我宁愿不去那条路(而且我没有足够深入地了解它是否符合我的要求).

例:

class A(object):

    foo = "don't change me"

    def __setattr__(self, name, value):
        raise ValueError

if __name__ == '__main__':
a1 = A()
print a1.foo # don't change me
print A.foo  # don't change me

A.foo = 'bar' # ideally throw an exception or something here
print A.foo   # bar
a2 = A()
print a1.foo  # bar
print a2.foo  # bar

这个问题的标题实际上是以前的考试问题,我正在寻找澄清/答案.

请注意,我正在学习Java并且正在熟悉它的语法.

我知道以前可能会问过这个问题,如果有的话,有人可以告诉我,如果可能的话,我可以在哪里提出这个问题吗？如果是这种情况,也请接受我的道歉.为了表明我一直在研究这个领域,我自己的理解是实例变量属于某个类(模板)的对象/实例,并且可以在需要时在该实例/对象中进行更改(变异).

类变量是一个只有一个副本且可以访问但不能被修改(变异？)的变量,但是所有类都可以根据需要使用它？

我在这里走在正确的轨道上吗？

另外,'静态'到底是做什么的？如果一个类的实例位于类的主实例中,那么它是静态的吗？

非常感谢.

这是我的第一个问题,很抱歉......我是python和编码的初学者,我想创建一个名为'Map'的类,它将具有以下类变量:

class Map:
    height = 11  
    width = 21

    top = [['#']*width]
    middle = [['#']+[' ']*(width-2)+['#'] for i in range(height-2)]
    field = top + middle + top

b = Map()

Shell:
>>> middle = [['#']+[' ']*(width-2)+['#'] for i in range(height-2)]
    NameError: name 'width' is not defined

如果我将变量放在类之外就可以了.我究竟做错了什么？？

谢谢您的帮助.

Rails 有一个名为的类扩展class_attribute，它允许继承类实例变量。这适用于不可变对象，例如String，但不适用于可变对象：

class Base
  class_attribute :options
  self.options = {}
end

class SubClass < Base
end

Base.options                   # {}
SubClass.options[:foo] = "bar" # { foo: "bar" }
Base.options                   # { foo: "bar" }

问题是如何让子类拥有自己的副本，options而不在其主体中显式初始化它：

class SubClass < Base
  self.options = {}
end

我见过像线程这对线程安全的Rails以及有关这一主题的各种网页,我敢肯定,每个人都在背诵它是什么,给什么不是线程安全的("类变量"秘诀"是伟大的!"),但我似乎永远无法在Rails中找到一个实际上不是线程安全的东西的清晰,简单,完整的例子,我想知道是否有人真正了解它.

如果有人可以证明我错了并给予:我将不胜感激:

• 一个清晰,简单,完整的例子,它在Rails中不是线程安全的.应该清楚代码的位置(即,如果它在控制器中,请显示它)并且不应该留给读者的想象(例如不存在的方法).此外,不应该有任何多余的代码或逻辑.

• 确切地说,两个用户在两个不同的线程上同时连接到网站的情况下会出现问题.

• 如何纠正这个问题.

更重要且与Rails相关的示例越好,所以如果您可以举例说明一个用户可能会看到另一个用户的数据(或类似数据),请执行此操作.

我正在尝试从类外部的方法访问类变量.

这是我的班级:

class Book

  @@bookCount = 0
  @@allBooks = []

  def self.allBooks
    @@allBooks
  end

  def self.bookCount
    @@bookCount
  end

  attr_accessor :name,:author,:date,:genre,:rating

  def initialize(name, author, date, genre, rating)
      @name = name
      @author = author
      @date = date
      @genre = genre
      @rating = rating
      @@bookCount += 1
      @@allBooks << self
  end

end

这是尝试访问类变量@@ bookCount的方法

def seeBookShelf
  if @@bookCount == 0
    puts "Your bookshelf is empty."
  else
    puts "You have " + @bookCount + " books in your bookshelf:"
    puts allBooks
  end
end

当我尝试执行该方法时,我得到了这个: …

试图在python中理解oop我遇到了困扰我的情况,我无法找到令人满意的解释......我正在构建一个Countable类,它有一个计数器属性,可以计算该类有多少个实例已初始化.我希望在初始化给定类的子类(或子类)时也增加此计数器.这是我的实现:

class Countable(object):
    counter = 0
    def __new__(cls, *args, **kwargs):
        cls.increment_counter()
        count(cls)
        return object.__new__(cls, *args, **kwargs)

    @classmethod
    def increment_counter(cls):
        cls.counter += 1
        if cls.__base__ is not object:
            cls.__base__.increment_counter()

哪里count(cls)有调试目的,后来我把它写下来.

现在,让我们有一些这样的子类:

class A(Countable):
    def __init__(self, a='a'):
        self.a = a

class B(Countable):
    def __init__(self, b='b'):
        self.b = b

class B2(B):
    def __init__(self, b2='b2'):
        self.b2 = b2

def count(cls):
    print('@{:<5}  Countables: {}  As: {}  Bs: {}  B2s: {}'
          ''.format(cls.__name__, Countable.counter, A.counter, B.counter, B2.counter))

当我运行如下代码时:

a = A()
a = A()
a …

假设使用类变量的简单ruby程序,

    class Holder
      @@var = 99
      def Holder.var=(val)
        @@var = val
      end
      def var
        @@var
      end
    end

    @@var = "top level variable"

    a = Holder.new
    puts a.var

我想结果应该是99,但输出不是99.我想知道为什么.由于类变量的范围是类,我假设该行@@var = "top level variable"不会影响类中的变量.

鉴于班级

from __future__ import annotations
from typing import ClassVar, Dict, Final
import abc

class Cipher(abc.ABC):
    @abc.abstractmethod
    def encrypt(self, plaintext: str) -> str:
        pass

    @abc.abstractmethod
    def decrypt(self, ciphertext: str) -> str:
        pass

class VigenereCipher(Cipher):
    @staticmethod
    def rotate(n: int) -> str:
        return string.ascii_uppercase[n:] + string.ascii_uppercase[:n]

    _TABLE: Final[ClassVar[Dict[str, str]]] = dict({(chr(i + ord("A")), rotate(i)) for i in range(26)})

编译失败（使用 3.8.0）

../cipher.py:19: in <module>
    class VigenereCipher(Cipher):
../cipher.py:24: in VigenereCipher
    _TABLE: Final[ClassVar[Dict[str, str]]] = dict({(chr(i + ord("A")), rotate(i)) for i in range(26)})
../cipher.py:24: …