Wie erstelle ich eine Konstante in Python?

Question

Wie deklariere ich eine Konstante in Python?

In Java machen wir:

public static final String CONST_NAME = "Name";

Answer 1

Sie können Tuple für Konstante Variablen verwenden :

• Ein Tuple ist eine geordnete und unveränderliche Sammlung

my_tuple = (1, "Hallo", 3.4)
print(my_tuple[0])

Answer 2

Dies ist zwar nicht genau konstant, aber ab Python 3.7 können Sie das dataclasses-Modul wie folgt verwenden:

from dataclasses import dataclass
from typing import Final

@dataclass(frozen=True)
class A():
    a1:Final = 3

a = A()

a.a1 = 4

---------------------------------------------------------------------------
FrozenInstanceError                       Traceback (most recent call last)
 in 
----> 1 a.a1 = 4

 in __setattr__(self, name, value)

FrozenInstanceError: cannot assign to field 'a1'

Answer 3

Einfach nur können Sie:

STRING_CONSTANT = "hi"
NUMBER_CONSTANT = 89

Ich hoffe, das macht alles viel einfacher

Answer 4

Kann nicht anders, als meine eigene sehr leichte minimalistische Metaclass-Implementierung bereitzustellen (die als Variation zur vorherigen Metaclass-Antwort erscheinen kann).

Konstanten werden in einer Container-Klasse gespeichert (keine Instanziierung erforderlich). Werte können einmal festgelegt werden, aber sobald sie festgelegt sind, können sie nicht geändert (oder gelöscht) werden.

Persönlich habe ich derzeit keinen Anwendungsfall dafür, aber es war eine lustige Übung.

class MetaConstant(type):
    ''' Metaclass, die es der zugrunde liegenden Klasse ermöglicht, Konstanten auf Klassenebene zu speichern (Instanzierung der Unterklasse nicht erforderlich).
        Nicht vorhandenen Attributen der zugrunde liegenden Klasse (Konstanten) können anfangs festgelegt werden, dürfen aber nicht geändert oder gelöscht werden.
    '''

    def __setattr__(klass, attr, value):
        'Wenn das Attribut (Konstante) nicht existiert, setze den Wert. Wenn das Attribut existiert, werfe AttributeError.'
        if hasattr(klass, attr):
            raise AttributeError(f'Kann den Wert der Konstanten {klass.__name__}.{attr} nicht auf {value} ändern'
                                 f' (der Wert von {klass.__name__}.{attr} ist bereits auf'
                                 f' {getattr(klass, attr)} festgelegt).')
        super().__setattr__(attr, value)

    def __delattr__(klass, attr):
        if hasattr(klass, attr):
            raise AttributeError(f'Kann Konstante {klass.__name__}.{attr} nicht löschen'
                                 f' (festgelegt auf {getattr(klass, attr)}).')

class Constants(metaclass=MetaConstant):
    'Containerklasse für Konstanten. Keine Instanziierung erforderlich.'
    #pass               # kommentieren, wenn keine Konstanten bei Klassenerstellung festgelegt sind
    B = 'Sechs'         # setzt Constants.B auf 'Sechs'

Constants.B = 6         # AttributeError
del Constants.B         # AttributeError

Constants.A = 'Fünf'   # setzt Constants.A auf 'Fünf'
Constants.A = 5         # AttributeError
del Constants.A         # AttributeError

Fühlen Sie sich frei, Verbesserungen vorzuschlagen.

Answer 5

Na ja.. auch wenn das veraltet ist, lasst mich hier meinen Senf dazugeben :-)

class ConstDict(dict):
    def __init__(self, *args, **kwargs):
        super(ConstDict, self).__init__(*args, **kwargs)

    def __setitem__(self, key, value):
        if key in self:
            raise ValueError("Wert %s existiert bereits" % (key))
        super(ConstDict, self).__setitem__(key, value)

Statt ValueError zu unterbrechen, kannst du verhindern, dass dort ein Update stattfindet. Ein Vorteil davon ist, dass du Konstanten dynamisch im Programm hinzufügen kannst, sie aber nicht ändern kannst, sobald eine Konstante festgelegt ist. Außerdem kannst du irgendwelche Regeln oder ähnliches hinzufügen, bevor du eine Konstante festlegst (so etwas wie Schlüssel muss ein String sein oder ein Kleinbuchstabe oder Großbuchstabe usw., bevor du den Schlüssel festlegst).

Allerdings sehe ich keine Bedeutung darin, Konstanten in Python festzulegen. Es können keine Optimierungen wie in C erfolgen und daher ist es meiner Meinung nach etwas, das nicht erforderlich ist.