标签: python-class

我正在寻找一种Python式的方法来在单个文件中定义多个相关常量以在多个模块中使用。我想出了多种选择，但它们都有缺点。

方法 1 - 简单的全局常量

# file resources/resource_ids.py

FOO_RESOURCE = 'foo'
BAR_RESOURCE = 'bar'
BAZ_RESOURCE = 'baz'
QUX_RESOURCE = 'qux'

# file runtime/bar_handler.py

from resources.resource_ids import BAR_RESOURCE

# ...

def my_code():
  value = get_resource(BAR_RESOURCE)

这很简单且通用，但有一些缺点：

• _RESOURCE必须附加到所有常量名称以提供上下文
• 在IDE中检查常量名称不会显示其他常量值

方法 2 - 枚举

# file resources/resource_ids.py

from enum import Enum, unique

@unique
class ResourceIds(Enum):
  foo = 'foo'
  bar = 'bar'
  baz = 'baz'
  qux = 'qux'

# file runtime/bar_handler.py

from resources.resource_ids import ResourceIds

# ...

def my_code():
  value = get_resource(ResourceIds.bar.value)

这解决了第一种方法的问题，但该解决方案的缺点是需要使用 …

@dataclass
class Stock:
    symbol: str
    price: float = get_price(symbol)

一个属性可以dataclass访问另一个属性吗？在上面的示例中，可以Stock通过提供符号和价格来创建 。如果未提供价格，则默认为我们从某个函数获取的价格get_price。有没有办法引用符号？

该示例生成错误NameError: name 'symbol' is not defined。

h.json考虑这个名为“我想将其转换为 python 数据类”的 json 文件。

{
    "acc1":{
        "email":"acc1@example.com",
        "password":"acc1",
        "name":"ACC1",
        "salary":1
    },
    "acc2":{
        "email":"acc2@example.com",
        "password":"acc2",
        "name":"ACC2",
        "salary":2
    }

}

我可以使用替代构造函数来获取每个帐户，例如：

import json
from dataclasses import dataclass

@dataclass
class Account(object):
    email:str
    password:str
    name:str
    salary:int
    
    @classmethod
    def from_json(cls, json_key):
        file = json.load(open("h.json"))
        return cls(**file[json_key])

但这仅限于数据类中定义的参数（电子邮件、姓名等）。

如果我要修改 json 以包含其他内容（例如年龄）怎么办？该脚本最终将返回一个TypeError，特别是TypeError: __init__() got an unexpected keyword argument 'age'.

有没有办法根据dict（json对象）的键动态调整类属性，这样我就不必每次向json添加新键时都添加属性？

背景

我使用数据类创建嵌套数据结构，用它来表示复杂的测试输出。

以前，我一直通过创建多个顶级数据类然后使用组合来创建层次结构：

from dataclasses import dataclass

@dataclass
class Meta:
    color: str 
    size: float

@dataclass
class Point:
    x: float
    y: float
    stuff: Meta

point1 = Point(x=5, y=-5, stuff=Meta(color='blue', size=20))

问题

我想知道是否有一种方法以独立的方式定义类，而不是用一堆较低级别的类污染我的顶级。所以上面， dataclass 的定义Point包含 的定义Meta，而不是顶层的定义。

解决方案？

我想知道是否可以将内部（数据类）类与数据类一起使用并使一切正常工作。

所以我尝试了这个：

rom dataclasses import dataclass
from typing import get_type_hints


@dataclass
class Point:

    @dataclass
    class Meta:
        color: str 
        size: float

    @dataclass
    class Misc:
        elemA: bool
        elemB: int 

    x: float
    y: float
    meta: Meta
    misc: Misc


point1 = Point(x=1, y=2,
               meta=Point.Meta(color='red', size=5.5), …

class A:
    def __init__(self):
        self.name = None
        self.a = 10
        self.b = 20
        self.c = 30
    def func1(self, param1, param2):
        def inner_func1(self, param1, param2):
            print(self, self.a, self.b)

        inner_func1(self, param1, param2)

a = A()
print(a)
a.func1(1,2)

我的第一个问题——将self参数传递给类方法的嵌套函数是否合法？我在 python-3.5.2 上运行此代码没有问题，并且都print()显示 A 类实例的相同地址。然而蟒蛇-3.6抱怨上线print(self, self.a, self.b)是self没有成员a。

同样有趣的是 PyCharm IDE 没有突出显示self这一行，而是说它“超出了外部范围”。

我到底做错了什么？

我在 python 类中使用 pybullet。我将其导入为import pybullet as p. 当我使用 pybullet 有多个类p的实例时，每个实例的类是否相同，还是每个实例的“变量”p 都是唯一的？

文件

import pybullet as p

class Foo:
    def __init__(self, counter):
        physicsClient = p.connect(p.DIRECT)
    def setGravity(self):
        p.setGravity(0, 0, -9.81)
(more code)

和 main.py

from foo import Foo

foo1 = Foo(1)
foo2 = Foo(2)
foo1.setGravity()

会setGravity()影响pfoo1 和 foo2 还是只影响 foo1？

我对 Python 上的一般装饰器和类很陌生，但有一个问题，是否有更好的方法来装饰 Pandas 对象。举个例子，我写了以下内容来创建两个方法——lisa 和 wil：

import numpy as np
import pandas as pd

test = np.array([['john', 'meg', 2.23, 6.49],
       ['lisa', 'wil', 9.67, 8.87],
       ['lisa', 'fay', 3.41, 5.04],
       ['lisa', 'wil', 0.58, 6.12],
       ['john', 'wil', 7.31, 1.74]],
)
test = pd.DataFrame(test)
test.columns = ['name1','name2','scoreA','scoreB']

@pd.api.extensions.register_dataframe_accessor('abc')
class ABCDataFrame:

    def __init__(self, pandas_obj):
        self._obj = pandas_obj

    @property
    def lisa(self):
        return self._obj.loc[self._obj['name1'] == 'lisa']
    @property
    def wil(self):
        return self._obj.loc[self._obj['name2'] == 'wil']

示例输出如下：

test.abc.lisa.abc.wil
  name1 name2 scoreA scoreB
1  lisa   wil   9.67   8.87
3  lisa …

我有这个代码：

class Employee:
    def __init__(self, name, pay, gender):
        self.name = name
        self.pay = pay
        self.gender = gender

    def add_raise(self):
        self.pay = int(self.pay*1.10)

    def __str__(self):
        if self.gender == "Female" or self.gender == "female":
            return f"{__class__.__name__} name: {self.name}, and she earns {self.pay} Pound"
        else:
            return f"{__class__.__name__} name: {self.name}, and he earns {self.pay} Pound"

    def __repr__(self):
        if self.gender == "Female" or self.gender == "female":
            return f"{__class__.__name__} name: {self.name}, and she earns {self.pay} Pound"
        else:
            return f"{__class__.__name__} name: {self.name}, and he earns {self.pay} Pound" …

我正在阅读方法重写，在其他语言中，似乎要完全重写，该方法必须具有相同的签名（参数、返回类型...等）

所以我试图检查 python 是否是这样工作的，我尝试了下一个代码

class Person():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def print_name(self, last_name):
        print(self.name + " " + last_name)

class Superhero(Person):
    def __init__(self, name, age, power):
        super().__init__(name, age)
        self.power = power

    def print_name(self):
        print(self.name)


human = Person("Ron", 23)
super_human = Superhero("Superman", 30, "Flying")

human.print_name("Wesley")
super_human.print_name("Kent")

我收到一个错误，super_human.print_name("Kent")它需要一个参数，但我传递了两个参数，我知道 MRO 存在于 python 中，我在其中查看（对象>类>父类），所以我想知道是否有一个这样我就可以调用print_name()父类中存在的函数而不是当前函数，因为它们采用不同的参数。

我一直试图调试我的代码，结果发现这是我错误的原因，很难找到。一个简单的例子来演示我在说什么：

class Test():
  def __init__(self):
    self.a = 0

x = Test()
x.b = 2
print(x.a)
print(x.b)

此代码不会抛出任何错误。事实上，它会成功打印出 0 和 2。所以即使 Test 不包含实例变量b，它仍然会在我分配它时创建它。如果我初始化第二个测试变量

y = Test()
print(y.b)

它会按预期抛出错误。

那么，为什么首先存在此功能，以便能够在类的实例上创建新属性？幕后发生了什么来实现这种行为？有什么方法可以禁用这种行为，或者至少在编程时以某种方式捕获它？

我有一个甲板类，我从中创建了一个甲板对象：

class Deck:
  cards = []

deck = Deck()

如何使甲板对象在调用时返回卡片列表？

print(deck)

# or

for card in deck:
  # do

不必总是调用deck.cards？