Code: Alles auswählen
class BAR():
def __init__(self):
self.foo1 = FOO()
Das mit den Klassennamen ist mir bekannt, habe das Beispiel aus dem Internet. Du hast recht, bei den kleinen Sachen ist es nicht notwendig, aber wenn ich z. B. das in verschiedenen Klassen nutzen möchte:Sirius3 hat geschrieben: Freitag 31. Mai 2019, 15:15 Das was Du hier tust, ist Komposition und ganz normal, denn das passiert ja auch, wenn Du einem Attribut eine neue Liste, einen Zahlenwert oder ähnliches zuweist.
Aus Deiner Beschreibung werde ich aber nicht ganz schlau, was Du mit Code-Sparen meinst. Vieles, was Du aufzählst, hört sich auf den ersten Blick nicht danach an, als ob Du dafür eine Klasse definieren müßtest. Am besten zeigst Du konkreten Code, was Du vorhast, dann kann man Dir am besten helfen.
Übrigens: Klassennamen werden CamelCase geschrieben, nicht komplett groß.
Code: Alles auswählen
class Security:
"""Main class for security."""
@staticmethod
def get_password(count, hard=False):
"""Creates a password.
:param count: int
:param hard: bool -> std False
Creates a password of the desired length. By default all
ascii letters are used (upper and lower case) and numbers.
If hard is on <True>, special characters are also used.
:return: str
"""
if hard:
x = string.ascii_letters + string.digits + string.punctuation
else:
x = string.ascii_letters + string.digits
return ''.join(secrets.choice(x) for _ in range(count))
Code: Alles auswählen
class FileBase:
def __init__(self, filepath):
self._filepath = filepath
self._user_extensions = []
self._excluded = []
self._files = []
def get_files_from_directory(self):
path = os.path.join(self._filepath, '**')
self._files.append(glob.glob(path, recursive=True))
return self._files
def get_specified_files_from_directory(self):
for root, directories, files in os.walk(self._filepath):
for directory in directories:
dir_path = os.path.join(root, directory)
print(dir_path)
for file in files:
file_path = os.path.join(root, directory, file)
print(file_path)
for excluded in self._excluded:
if excluded not in file_path:
self._files.append(file_path)
print(self._files)
def set_excluded_list(self, excluded):
"""Terms or paths that are not used in the search.
:param excluded: <list|tuple> <list|tuple>. Delivery as list.
:return: None
"""
if type(excluded) == list or type(excluded) == tuple:
self._excluded.extend(excluded)
def set_file_extensions_list(self, extensions):
"""Sets the list of file extensions.
:param extensions: <list|tuple>. Delivery as list.
:return: None
"""
if type(extensions) == list or type(extensions) == tuple:
self._user_extensions.extend(extensions)
Code: Alles auswählen
def get_root_password(self):
pw_len = self._inputs('root password length (1 - 100): ')
return Security.get_password(pw_len)Das mit dem 'Entwurfsproblem' ist meine Intention für diese Frage.__blackjack__ hat geschrieben: Freitag 31. Mai 2019, 15:24 @Schwarzer Wolf: Vererbung vs. Komposition hat nichts mit Code sparen zu tun, und „statische Methoden“ klingt in diesem Zusammenhang verdächtig nach einem Entwurfsproblem, denn so etwas ist in Python eher selten, denn statische Methoden sind ja eigentlich Funktionen. Und die werden ausserhalb von Klassen definiert.
Code: Alles auswählen
def create_password(length, hard=False):
"""Create a password.
:param length: int
:param hard: bool -> std False
Creates a password of the desired length. By default all
ascii letters are used (upper and lower case) and numbers.
If hard is on <True>, special characters are also used.
:return: str
"""
characters = string.ascii_letters + string.digits
if hard:
characters += string.punctuation
return ''.join(random.choice(characters) for _ in range(length))
def get_paths(path):
return glob.glob(os.path.join(path, '**'), recursive=True)
def get_filenames(path, excluded=()):
result = list()
for root, _, filenames in os.walk(path):
for filename in filenames:
full_path = os.path.join(root, filename)
if not any(part in full_path for part in excluded):
result.append(full_path)
return result__blackjack__ hat geschrieben: Freitag 31. Mai 2019, 16:17 @Schwarzer Wolf: Was ist eigentlich `secrets.choice()`? Hast Du etwa das `random`-Modul in `secrets` umbenannt?
Also ich packe alles in Module oder Pakete. Und Klassen dann nur, wenn ich etwas brauche, was einen Zustand hat? Beispielsweise ein Sensor bei einem Robot?
Ich habe bisher schon mehrere statische Methoden innerhalb von Klassen definiert, wenn man deren Funktionalität außerhalb der Klasse nicht gebrauchen kann. Sind das eher schlechte Entscheidungen gewesen?__blackjack__ hat geschrieben: Freitag 31. Mai 2019, 15:24 @Schwarzer Wolf: Vererbung vs. Komposition hat nichts mit Code sparen zu tun, und „statische Methoden“ klingt in diesem Zusammenhang verdächtig nach einem Entwurfsproblem, denn so etwas ist in Python eher selten, denn statische Methoden sind ja eigentlich Funktionen. Und die werden ausserhalb von Klassen definiert.
Ich denke nicht dass das immer ein Anzeichen für ein schlechtes Design ist. Eine statische Methode hast du ja dann, wenn diese nicht zwangsweise auf Attribute der Klasse zugreifen muss. Manchmal möchte man diese Methode aber nicht als Funktion auf Modulebene auslagern, sondern lieber im Namensraum der Klasse definieren, wodurch die Absicht der Methode etwas verdeutlicht wird.Atalanttore hat geschrieben: Freitag 31. Mai 2019, 20:09 Ich habe bisher schon mehrere statische Methoden innerhalb von Klassen definiert, wenn man deren Funktionalität außerhalb der Klasse nicht gebrauchen kann. Sind das eher schlechte Entscheidungen gewesen?
Atalanttore
