10

我是 Python 的绝对新手（我来自 Java），我对类字段有以下疑问。

考虑这样的代码：

class Toy():
    def __init__(self, color, age):
        self.color = color
        self.age = age

action_figure = Toy('red', 10)

好的，做了什么很清楚也很简单：

它正在定义一个玩具类。在构造方法中定义了两个字段以及如何设置字段值。最后（在“main”中）创建了一个新的Toy实例，传递构造函数调用中的字段值。

好的，很清楚......但我有一个疑问。在 Java 中定义同一个类我做这样的事情：

public class Toy {
    private String color;
    private int age;

    // CONSTRUCTOR:
    public Dog(String color, int age) {
        this.color = color;
        this.age = age;
    }
}

好的，它很相似，但我发现了一个很大的不同。在我的 Java conde 中，我将类字段声明为构造函数方法之外的变量。在 Python 中，我直接在构造函数方法中定义类字段。所以这意味着在 Java 中我可以声明 n 个类字段并使用构造函数方法仅初始化这些字段的一个子集，例如：

public class Toy {
    private String color;
    private int age;
    private String field3;
    private String field4;
    private String field5;

    // CONSTRUCTOR:
    public Dog(String color, int age) {
        this.color = color;
        this.age = age;
    }
}

我还有field3、field4和field5字段，它们不会被我的构造函数初始化（以防我可以使用 setter 方法第二次设置它们的值）。

我可以在 Python 中做类似的事情吗？我可以在构造函数方法之外声明类字段吗？

4

5 回答 5

10

python 中的类与 c++/java 中的类根本不同，因为 c++/java 类具有固定的数据结构和大小（字节），因为每个属性都是在所有方法之外声明或定义的（通常作为私有变量），但在 python 中，一切都是即时（动态输入）。

实例变量（任何带有 的self.）只能在方法中定义。在构造函数与其他方法中定义属性的选择是关于其他人能够快速理解您的代码/数据结构（尽管由于动态性调用 python 类数据结构是不合适的）

作为动态性的示例，您甚至可以在运行时向类甚至实例添加新方法和属性：

class A:
    pass

在运行时向类添加东西（这些将被添加到类的所有现有和未来实例中）：

A.key = val

def f(self):
    return 0

A.myfunction = f
a = A()
a.myfunction()
# 0

在运行时向单个实例添加内容：

a=A()
a.attr='something'

def f(self):
    return 0

a.fun=f.__get__(a)
a.fun()
# 0
于 2019-12-14T16:52:42.493 回答
7

在 python 中，你可以这样做：

class Toy():
    def__init__(self, color, age):
        self.color = color
        self.age = age

    def another_method(self, f):
         self.field3 = f + 4
         return self.field3

但通常建议为了清楚起见（这里有更多参数：https ://stackoverflow.com/a/38378757/4709400 ）来初始化构造函数中的所有实例变量，所以你会这样做：

class Toy():
    def__init__(self, color, age):
        self.color = color
        self.age = age
        self.field3 = None
        self.field4 = 0 # for instance
        self.field5 = "" # for instance

    def another_method(self, f):
         self.field3 = f + 4
         return self.field3
于 2019-12-14T16:41:34.633 回答
4

在 Python 中真的不需要这个。您可以在需要时将 Java 中的“实例变量”添加到类的实例中：

class Person:

    def __init__(self, name):
        self.name = name

    def get_a_job(self):
        self.job = "Janitor"
        print(f"{self.name} now has a job!")

p1 = Person("Tom")
p2 = Person("Bob")

p1.get_a_job()
print(p1.job)

print(p2.job)

输出：

Tom now has a job!
Janitor
Traceback (most recent call last):
  File "...", line 17, in <module>
    print(p2.job)
AttributeError: 'Person' object has no attribute 'job'
>>>
于 2019-12-14T16:38:24.890 回答
2

由于 Python 是动态类型的，因此您无需事先声明变量，而是在运行时对其进行初始化。这也意味着您不必向构造函数添加实例属性，但您可以在以后随时添加它们。事实上，您可以为任何对象添加属性，包括类对象本身。向构造函数添加实例属性主要是一致性和可读性的问题。

添加到类定义中的数据属性在 Python 中称为类属性（我不懂 Java，但我相信，这对应于静态变量）。这对于跟踪所有类实例很有用：

class Dog:
  lineage = {'Phylum':'Chordata', 'Class':'Mammalia', 'Species':'Canis lupus'}
  all_dogs = []

  def __init__(self, fur_color, tail_length):
    self.fur_color = fur_color
    self.tail_length = tail_length
    self.all_dogs.append(self)  # class attributes can be accessed via the instance

Bello = Dog('white',50)
print(Dog.all_dogs)
print(Dog.[0].fur_color)
于 2019-12-14T16:56:36.380 回答
0

正如您所指出的，这不是核心 python 语言的一部分。

这对我来说也是一个缺失的功能，原因如下：

  • 可读性/可维护性：使用在构造函数或其他地方动态定义属性的经典 python 方式，在阅读代码时，对象的“合同”（或至少预期的鸭合同）是什么并不明显。

  • 紧凑性：用just创建长构造函数self.<foo> = <foo>并不是最有趣的，你需要的字段越多，你必须编写的行数越多

  • 扩展字段契约的能力，例如在默认值可变的情况下添加默认值工厂，或添加值验证器

  • 创建混合类的能力，即实现依赖于某些字段的某些功能的类，但不强制使用任何构造函数。

这就是我创建pyfields. 使用这个库，每个字段都被定义为一个类成员：

from pyfields import field
from typing import List

class Toy:
    color: str = field(doc="The toy's color, a string.")
    age: int = field(doc="How old is this Toy. An integer number of years.")
    field3: str = field(default='hello', check_type=True)
    field4: List[str] = field(default_factory=lambda obj: ['world'])
    field5: str = field(default=None, 
                        validators={'should be 1-character long': lambda x: len(x) == 1})

    def __init__(self, color, age):
        self.color = color
        self.age = age


t = Toy(color='blue', age=12)
print(t.field3 + ' ' + t.field4[0])
print(t.field5 is None)
t.field5 = 'yo'

产量

hello world
True
Traceback (most recent call last):
  ...
valid8.entry_points.ValidationError[ValueError]: Error validating [Toy.field5=yo]. InvalidValue: should be 1-character long. Function [<lambda>] returned [False] for value 'yo'.

请注意，我使用上面的 python 3.7+ 类型提示语法，但pyfields与旧版本（python 2、python 3.5）兼容，请参阅文档。

您甚至可以通过自动创建构造函数或使用为您@autofields生成field()调用来进一步简化此示例。pyfields还提供了一个@autoclass，因此您甚至可以轻松地生成其他类行为，例如字符串表示、相等、转换为 dict 等。请参阅autoclass doc。

请注意，pyfields它的灵感来自于 等巨人attrs，但它的独特之处在于它保留了隔离原则。__init__所以它不会在你的背后或__setattr__背后摆弄。因此，这允许您的字段在集合中进行验证（不仅在构造函数中），还可以开发优雅的混合类定义字段和方法，但没有构造函数。

于 2020-03-30T13:06:12.693 回答