it-swarm.com.de

was ist der beste Weg, um konstante Variablen zu definieren? Python 3

Ich schreibe ein Programm in Python, das viele konstante Variablen enthält. Ich möchte eine Datei erstellen, die alle diese Variablen wie .h-Datei in C enthält und viele #define enthält. Ich habe versucht, configparser zu verwenden, jedoch fand ich es nicht einfach und lustig, es zu benutzen. 

Kennen Sie einen besseren Weg? 

4
TomE8

Python erlaubt keine Konstantendeklaration wie in C oder C++.

Normalerweise werden in Python Konstanten groß geschrieben ( PEP 8 standards), was dem Programmierer hilft zu wissen, dass es eine Konstante ist. 

Ex. MY_CONSTANT = "Whatever"

Eine andere gültige Methode, die ich nicht benutze, aber davon gehört habe, ist die Verwendung einer Methode:

def MY_CONSTANT():
    return "Whatever"

In der Theorie verhält sich der Aufruf von MY_CONSTANT() wie eine Konstante.

EDIT

Wie der Kommentar sagt, kann jemand den Wert ändern, indem er anruft

MY_CONSTANT = lambda: 'Something else'

vergessen Sie jedoch nicht, dass dieselbe Person im ersten Beispiel MY_CONSTANT = "Something else" aufrufen und den Ausgangswert ändern kann. In beiden Fällen ist es unwahrscheinlich, aber möglich.

10
scharette

Es gibt keine Konstanten in Python, wie sie in C oder Java vorhanden sind. Sie können sie durch Funktionen imitieren:

def FOO():
  return "foo"

Sie können den Funktionsaufruf in eine Eigenschaft einschließen, sodass er wie eine Variable aussieht:

class Const:
  @property
  def FOO(self):
    return "foo"

CONST = Const()  # You need an instance

if something == CONST.FOO:
  ...

Mit etwas Meta-Zeug können Sie mit einer knappen Syntax unsetbare Attribute erhalten:

def const(cls):
    # Replace a class's attributes with properties,
    # and itself with an instance of its doppelganger.
    is_special = lambda name: (name.startswith("__") and name.endswith("__"))
    class_contents = {n: getattr(cls, n) for n in vars(cls) if not is_special(n)}
    def unbind(value):  # Get the value out of the lexical closure.
        return lambda self: value
    propertified_contents = {name: property(unbind(value))
                             for (name, value) in class_contents.items()}
    receptor = type(cls.__name__, (object,), propertified_contents)
    return receptor()  # Replace with an instance, so properties work.


@const
class Paths(object):
    home = "/home"
    null = "/dev/null"

Jetzt können Sie auf Paths.home als normalen Wert zugreifen, jedoch keine Zuweisungen vornehmen. Sie können mehrere Klassen definieren, die mit @const verziert sind, da Sie möglicherweise mehrere .h-Dateien verwenden.

3
9000

Sie können so etwas verwenden:

Dateistruktur:

myapp/
    __init__.py
    settings.py
    main.py

einstellungen.py

CONST_A = 'A'
CONST_B = 'B'

__init__.py

from . import settings as global_settings


class Settings:

def __init__(self):
    for setting in dir(global_settings):
        if setting.isupper():
            setattr(self, setting, getattr(global_settings, setting))

def __setattr__(self, attr, value):
    if not getattr(self, attr, None):
        super().__setattr__(attr, value)
    else:
        raise TypeError("'constant' does not support item assignment")


settings = Settings()

main.py

import settings

print(settings.CONST_A)  # prints A

settings.CONST_A = 'C'  # raises TypeError error

print(settings.CONST_A)  # prints A

settings.CONST_C = 'C'  # also able to add new constants
print(settings.CONST_C)  # prints C

Durch Überschreiben von __setattr__ in der Klasse Settings werden alle Attribute schreibgeschützt. Die einzige Voraussetzung ist, dass alle Konstanten in Ihrer settings.py in Großbuchstaben geschrieben sind. dass es nicht funktionieren wird, wenn Sie Variablen direkt importieren:

from settings import CONST_A

print(settings.CONST_A)  # prints A

settings.CONST_A = 'C'  # sets C

print(settings.CONST_A)  # prints C
1
Artem Nepo

Python ist nicht vorverarbeitet. Sie können einfach eine Datei constant.py erstellen

#!/usr/bin/env python
# encoding: utf-8
"""
constant.py
"""

MY_CONSTANT = 50

Importieren Sie die Datei constant.py, wenn Sie konstante Werte wünschen, wie im folgenden Beispiel.

#!/usr/bin/env python
# encoding: utf-8
"""
example.py
"""
import constant
print constant.MY_CONSTANT * 2

Auf diese Weise können Sie Konstanten projektübergreifend verwenden.

Sie haben auch die Möglichkeit, wenn die Konstanten an eine bestimmte Klasse gebunden sind und privat innerhalb dieser Klasse verwendet werden, sie für diese Klasse spezifisch zu machen:

class Foo(object):
   GOOD = 0
   BAD = 1

   def __init__(self...

Wenn Sie das gesamte Modul definieren und verwenden möchten, legen Sie es auf das Modul

PIE = 3.47

class Foo(object):
   def __init__(self...
0
Ankireddy

Definieren Sie einfach eine constants.py-Datei und schreiben Sie alle Ihre Konstanten. Es gibt keinen anderen Zaubertrick in Python. Verwenden Sie Kappen als allgemeine Konvention.

0
saran3h