(me = BA Student)
mit Python habe ich noch nicht lange zutun, jedoch traf ich bereits zweimal auf die Problematik,
daß ich ein PythonScript versehen mit Parametern aufrufen wollte (der Aufruf dieser Scripte erfolgt im Makefile).
Nachdem ich quasi zweimal genau das gleiche in den Quellcode geschrieben habe (von unterschiedlichen Namen und deren Anzahl abgesehen),
kam mir die Idee, daß es vielleicht geschickter wäre, ein allgemeines Modul zu verwenden, um dann einfach Objekte zu erzeugen,
denen ich als Name den gewünschten Parameter übergebe ..
Öh, gedacht, etwas feiner gedacht, getan
Hiermit kann ich eine beliebige Menge von Parametern erzeugen, und verwalten -
Mit dem Verwalten ist das Auslesen von der Konsole und die Rückgabe der zugehörigen Werte gemeint.
Ich muss lediglich ein Objekt der Klasse myParameter, dem ich auch gleich meine Parameternamen mitgebe, erzeugen.
Im Folgenden wende ich auf das Objekt die Methode handleOptions() an, und danach lass ich mir mit getValueOf(<paraName>) den Wert zurück geben
Hm versteht überhaupt jemand was ich erzähle ? ^^
Nuja, soviel sei noch gesagt, ich gebe zu, daß sich kein Nutzen hinsichtlich weniger Code im letztendl. Script einstellt.
Aber das ist mir egal, denn mein erstes Modul steht
Nun es gibt vielleicht nette Anmerkungen/Tipps hinsichtl. des Codes, oder vielleicht findet jemand Fehler, oder jemand hat eine Frage ?
Dann keine Scheu - ich freu mich auf eure Antworten
Code: Alles auswählen
# -*- coding: ISO8859-1 -*-
# ------------------------------------------------------
# dieses Modul realisiert die Klasse "myParameter" die vom Benutzer
# definierte Parameter (beliebig viel) aus der Kommandozeile ausliest
#
# Die Idee ist objektorientiert:
# Möchte man zb. ein Pythonscript mit Parametern versehen,
# so erzeugt man ein Objekt der hier zur Verfügung gestellten Klasse
# "myParameter" und übergibt dabei die gewünschten Parameter
# (genauer den Namen der Parameter)
# Hinweis: Es ist vereinbart, daß entweder direkt Strings übergeben werden,
# oder aber eine bzw. mehrere Liste(n) von Strings
# Sollte dies nicht der Fall sein,
# wird ein Error mit dem Namen "typError" verursacht
#
# Ein Objekt myParameter enthällt dann mehrere Parameter,
# deren Werte vorerst leere Strings sind.
# Ansprechbar von außen sind diese mit der Methode
# "getValueOf(*parameter)" (genaueres siehe Methodenbeschreibung)
# Zum Ermitteln/Einlesen der Werte der definierten Parameter
# von der Kommandozeile muss die Methode "handleOptions()"
# auf das Objekt angewendet werden (genaueres siehe Methodenbeschreibung)
#
# Die Benutzung ist sehr simpel gehalten,:
# 1. neues Objekt obj erzeugen (dabei alle später verfügbaren Parameter übergeben)
# 2. obj.handleOptions() aufrufen
# 3. von obj.getValueOf(xyz) den Wert von xyz holen
#
##############
# WICHTIG:
##############
# 2 Möglichkeiten für die Syntax auf der Kommandozeile oder Makefile
# --option=value
# --option
##############
# Der erste Fall führt zu einer Wertabspeicherung als String !
# Der zweite Fall führt zu einer Wertabspeicherung
# als Booleanscher Wert: True !
##############
#
import sys
# Klasse myParameter
class myParameter:
# ------------
# init
def __init__(self, *NamesOrLists):
# Error der erzeugt wird, wenn andere Typen außer String übergeben werden
self.typError="typError - str/list erlaubt, verwendet"
# Error der erzeugt wird, wenn unbekannte Parameter gelesen
# (von der Konsole) oder übergeben werden
self.unknownParameter = "unbekannter Parameter"
# hier stehen später die Optionen (Objekte von der Klasse _someOption) drin
self._OptionList = []
# gegebene Optionsnamen werden als Option in die Liste eingefügt
# impliziert Prüfung auf Typkonsistenz und evt. Fehlererzeugung
# (letzteres in Methode _appendOption(blub))
for onePart in NamesOrLists:
if type(onePart) == str:
self._appendOption(onePart)
elif type(onePart) == list:
for entry in onePart:
if type(entry) == str:
self._appendOption(entry)
else:
raise self.typError, type(entry)
else:
raise self.typError, type(onePart)
# ------------
# handleOptions
def handleOptions(self):
# Variablendeklarationen
_OptionNames = self._getOptionNames()
# es wird die Kommandozeile eingelesen,
# sollte ein unbekannter Parameter gelesen werden,
# wird der "unknownParameter" Fehler erzeugt
for Strings in sys.argv[1:]:
# an Syntax --option_name=value oder --option_name gebunden !!
slicedString = Strings[2:].split("=")
givenOption = slicedString[0]
# wenn die Länge von der Liste größer als 1 ist,
# dann steht noch der zugehörige Wert drin
if len(slicedString) > 1:
relatedValue = slicedString[1] # String als Optionsinhalt speichern
else:
relatedValue = True # True als Optionsinhalt speichern
# immer dann falsch,
# wenn eine eingelesende Option nicht gefunden werde konnte
_wasFound=False
# es werden die vorhandenen Optionen nun durchlaufen,
# und mit den eingelesenden abgeprüft
for predefinedOption in self._OptionList:
# wenn eine angegebene Option gleichnamig einer vordefinierten ist,
# so überschreibe deren Wert mit dem angegebenen
if givenOption == predefinedOption.getName():
predefinedOption.setValue(relatedValue)
_wasFound=True
break
else:
_wasFound=False
# wenn eine Option nicht gefunden werde konnte,
# wird der Fehler "unknownParameter" erzeugt
if _wasFound==False:
_OptionTip = ""
for _option in _OptionNames:
_OptionTip=_OptionTip+_option+" "
_ErrorMessage =
"ein oder mehrere Parameter von der Kommandozeile wurden nicht gefunden.\n"+\
"Hinweis: korrekte Syntax lautet: --option_name= \n"+\
"Hinweis: definierte Parameter: "+_OptionTip
raise self.unknownParameter, _ErrorMessage
# ------------
# getValueOf
def getValueOf(self, *NamesOrLists):
_ValueList = []
# gegebene Optionsnamen werden mit vorhandenen geprüft
# und deren Werte zurückgegeben
# Rückgabetyp entsprecht Eingabetyp,
# so zb. liefert eine Liste mit Optionen eine Liste mit den zugehörigen Werten
# impliziert Prüfung auf Typkonsistenz und evt. Fehlererzeugung
for onePart in NamesOrLists:
if type(onePart) == str:
_ValueList.append(self._getValueOf(onePart))
elif type(onePart) == list:
for entry in onePart:
_ValueList.append(self._getValueOf(entry))
else:
raise self.typError, type(onePart)
# ist Liste mit mehr als einem Wert gefüllt, so wird die Liste selbst übergeben
# falls nicht, so wird das Element an sich (dann vom Typ String) übergeben
if len(_ValueList) > 1:
return _ValueList
else:
return _ValueList[0]
# ------------
# _appendOption
def _appendOption(self, OptionName):
self._OptionList.append(_someOption(OptionName))
# ------------
# _getOptionNames
def _getOptionNames(self):
returnNameList = []
for option in self._OptionList:
returnNameList.append(option.getName())
return returnNameList
# ------------
# _getValueOf
def _getValueOf(self, givenOption):
for predefinedOption in self._OptionList:
if givenOption == predefinedOption.getName():
return predefinedOption.getValue()
_ErrorMessage = "'"+givenOption+"' ist kein definierter Parameter"
raise self.unknownParameter, _ErrorMessage
# -------------------
# someOption class
class _someOption:
# init
def __init__(self, Name, Value=False):
self.Name = Name
self.Value = Value
# setValue
def setValue(self, Value):
self.Value = Value
# getValue
def getValue(self):
return self.Value
# getName
def getName(self):
return self.Name
