Verwandte Themen

aeskulap787
10.09.2024, 19:41
Wie kann man ein weitverzweigtes Geflecht aus if/else-Anweisungen in Python (oder in anderen Programmiersprachen) programmieren?

Wenn man als absoluter Laie in Programmierung im Internet zur if/else-Anweisung (egal, in welcher Programmiersprache) recherchiert, wird man schnell feststellen, dass die Infos, die man hier findet, nicht allzu reichhaltig sind.

Das höchste der Gefühle, was einem beigebracht wird, ist folgenden Dialog zu programmieren: "Welche Sprache sprechen Sie?" - "Französisch." - "Wollen Sie sich auf Französisch weiter unterhalten?" Ende.

Man lernt nicht, wie man mit dem Programm weitermachen kann, falls die Antwort des Benutzers "Ja" sein sollte. Man erfährt gar nichts. Was zu finden ist, ist, wie man EINE FRAGE STELLT und dann auf EINE ANTWORT zu dieser Frage reagieren kann. Das war's.

Ich wüsste gern, wie man das weiterspinnen kann. Wie man eine ganz lange Unterhaltung mit allen möglichen Antwortmöglichkeiten programmieren kann. So wie bei einem Windows-Installationassistenten, der dafür sorgt, dass Windows unter hundert verschiedenen Arten auf die Art installiert wird, wie der Benutzer es will.

Wenn die Benutzer dieser Seite keine Antwort auf die Frage haben, weil sie es selbst nicht wissen, ist das überhaupt kein Problem. Man trifft immer wieder einen It-Profi, der es vielleicht weiß.

Allerdings lässt sich extrem leicht feststellen, dass irgendwelche Teenies oder Leute, die auf dem geistigen Niveau von (nicht sehr gut erzogenen) Teenies stehengeblieben sind, es sich zum Hobby machen, auf dieser Seite unvorstellbar bösartig und beleidigend zu antworten. Es ist völlig egal, was man fragt, egal ob "Wie heißt das weiße Zeug, das früher auf den Donuts war?" oder "In welchen Läden kann man viele naturfreundliche Reinigungsmittel kaufen?" Es wird immer geantwortet von irgendwelchen Leuten, die zu wenig zu tun haben und sich ihre Zeit vertreiben, Leute im Internet mit Sprüchen wie "Boah, Alta, wie dumm BIIISSSSST Du eigentlich?" zu beleidigen.

Ich werde auf so einen Schwachsinn nicht antworten, auch nicht auf "gut gemeinte Rückfragen" und schon gar nicht auf "Also, mit SO EINER NEGATIVEN EINSTELLUNG MENSCHEN GEGENÜBER würde ich hier aber KEINE Frage stellen".

Die Frage ist klar formuliert, so klar wie sie klarer nicht formuliert werden kann. So wie "Was ist 2 + 2?" Wenn jemand die Antwort wüsste, würde mich das sehr freuen. Wenn nicht, dann nicht.

Danke, Ende.

Computer, IT, programmieren, Java, Anwendungsentwicklung, C Sharp, Programmiersprache, Python, Softwareentwicklung, Webentwicklung, Rust, Programmcode, Objektorientierte Programmierung
6 Antworten
LDM158
17.07.2024, 13:41
Customtkinter "master" Parameter beim erstellen von einem Textfeld?

Hey,

ich habe eine Klasse erstellt die ein Hauptfenster erstellt und möchte aus einer anderen klasse einen Textfeld erstellen der sich auf das Hauptfenster bezieht.
So wie ich es verstanden habe braucht man dafür den Parameter "master" um vorzugeben in welchem Fenster nun der Textfeld angezeigt werden soll.
Leider funktioniert das bei mir nicht so richtig. Hat jemand davon Ahnung und kann mir meinen Fehler zeigen?
lieben Dank! :)

main.py

import view
import controller
import customtkinter as ctk

class Main(view.MainWindow):
   def __init__(self):
       super().__init__()
       self.main_window = view.MainWindow()
       self.main_window.set_size("1680", "900")
       self.main_window.set_title("YourTerminal")
       controller.InputBoxMain()# Nach meinem Verständnis muss hier der Master-Parameter angegeben werden. Wie übergebe ich diesen?

   def run(self):
       self.main_window.get_window().mainloop()

if __name__ == "__main__":
    app = Main()
    app.run()

view.py

import customtkinter as ctk


class MainWindow:
   def __init__(self):
       self.window = ctk.CTk()

   def set_size(self, width, height):
       self.window.geometry(f"{width}x{height}")

   def set_title(self, title):
       self.window.title(title)

   def get_window(self):
       return self.window

class WindowTemplate:
   def __init__(self):
       self.window = ctk.CTkToplevel()

   def set_size(self, width, height):
       self.window.geometry(f"{width}x{height}")

   def set_title(self, title):
       self.window.title(title)

   def get_window(self):
       return self.window

# der master Parameter gibt an wo diese Box angezeigt werden soll
class InputBoxTemplate:
    def __init__(self, master):  # Wie übergebe ich den master Parameter?
        self.master = master
        self.box = ctk.CTkEntry(self.master)

    def set_size(self, width, height, y, x):
        self.box.place(width=width, height=height, pady=y, padyx=x)

    def set_placeholder(self, placeholder):
        self.box._placeholder_text(f"{placeholder}")

controller.py

import view
import customtkinter as ctk
import main
class InputBoxMain(view.InputBoxTemplate, main.Main):
    def __init__(self):
        super().__init__()
        self.master = ctk.CTk()
        self.window = view.InputBoxTemplate(self.master)# Oder der Master-Parameter wird hier übergeben? Hier versuche ich master auf ctk.CTk zu beziehen. Das ist das Haupfenster.
        self.window.set_size(200, 200, 10, 10)
        self.window.set_placeholder("Hier steht der Placeholder")

Hier die Fehlermeldung falls relevant:

Traceback (most recent call last):

 File , line 1, in <module>

  import view

 File , line 2, in <module>

  import main

 File , line 2, in <module>

  import controller

 File " line 4, in <module>

  class InputBoxMain(view.InputBoxTemplate, main.Main):

            ^^^^^^^^^^^^^^^^^^^^^

AttributeError: partially initialized module 'view' has no attribute 'InputBoxTemplate' (most likely due to a circular import)

Code, Programmiersprache, Python, Python 3, Objektorientierte Programmierung, Tkinter, Pycharm
1 Antwort
LDM158
16.07.2024, 16:16
Python programmieren, Objektorientierte Programmierung in verschiedenen Dateien mit Klassen?

Hey,

ich lerne aktuell Python und habe angefangen einen Chatbot zu programmieren.
Nun will ich anfangen mir anzugewöhnen in verschiedenen Dateien mit Objektorientierter Programmierung zu programmieren bzw. das erstmal zu lernen.
Mein Gedanke in meinem Code ist z.B. eine Klasse WindowTemplate zu erstellen und diese als Blaupause ohne vorgegebene Werte zu definieren.
An Sich gelingt mir das auch aber ich habe Probleme von einer anderen Klasse aus einer anderen Datei darauf zuzugreifen und die Werte für wie zum Beispiel Größe oder Titel zu übergeben.
Ich würde mich freuen wenn hier mal jemand der etwas Erfahrung hat drauf schauen könnte und mich zumindest mal in die richtige Richtung leiten kann. :)
Viele Dank!

main.py

Fehlermeldung ist diese:

Traceback (most recent call last):

line 17, in <module>

  app = Main()

     ^^^^^^

line 9, in __init__

  self.main_window.set_size("1680", "900")

line 10, in set_size

  self.window_size.geometry(f"{width}x{height}")

  ^^^^^^^^^^^^^^^^^^^^^^^^^

AttributeError: 'NoneType' object has no attribute 'geometry' 

import view
import customtkinter as ctk


class Main(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.main_window = view.WindowTemplate()
        self.main_window.set_size("1680", "900")
        self.main_window.set_title("YourTerminal")

    def my_mainloop(self):
        self.mainloop()


if __name__ == "__main__":
    app = Main()
    app.my_mainloop()

view.py

import customtkinter as ctk


class WindowTemplate:
    def __init__(self, window_size=None, window_title=None):
        self.window_size = window_size
        self.window_title = window_title

    def set_size(self, width, height):
        self.window_size.geometry(f"{width}x{height}")

    def set_title(self, title):
        self.window_title.title(title)
Code, Programmiersprache, Python, Python 3, Objektorientierte Programmierung, Tkinter, Pycharm
1 Antwort
CodeSnake
18.05.2023, 18:08
Beitrag wurde 1 Mal erneut eingestellt
Mit Links
Vererbung von Klassen in Python mit super()?

Hallo Community,

ich habe hier jetzt schon oft gefragt, was diese drei Zeilen bedeuten:

class HangmanGame(BoxLayout):
      def __init__(self, **kwargs):
          super().__init__(**kwargs)

Den gesamten Code gibt es hier zum nachlesen:
https://www.gutefrage.net/frage/wozu-das-super-initkwargs

Jetzt habe ich schon viele Antworten bekommen, vor allem von regex9 und KarlRanseierlll denen ich hier auch noch mal danken möchte.

Aber ich habe es immer noch nicht ganz verstanden und ich bin inzwischen echt verzweifelt. Ich habe aber ein Video dazu gefunden, was ich hier eben verlinke:
https://www.youtube.com/watch?v=QUHnJrFouv8&list=PLzMcBGfZo4-kSJVMyYeOQ8CXJ3z1k7gHn

Konkret geht es um Minute 1:10-3:50. Da sagt er ja, man wisse nicht, wie viele Argumente man bekommt.

Dazu habe ich dann auch direkt meine erste Frage. Ich verstehe nämlich nicht, welche Argumente er meint. Die in der __init__() Methode der Klasse, oder die die man beim erstellen einer Instanz in den Klammer übergeben kann, oder ganz andere? Und wen er die beim erstellen der Instanz meint, frage ich mich, warum nur diese übergeben werden und nicht auch die aus der __init__()-Methode.

Meine zweite Frage wäre dann, ob die beiden Zeilen überhaupt zusammenhängen, oder ob in der Zeile mit dem super() andere kwargs gemeint sind.

Und meine dritte und letzte Frage wäre, warum man diese kwargs-Argumente an die Basisklasse BoxLayout übergeben muss. Bei dieser Frage bitte ich um eine ausführliche aber einfache Antwort. Ich bin nämlich erst 14 und echt nicht der beste in Python. Diese Frage aber bitte nur beantworten wenn Sie sich wirklich damit auskennen oder schon Erfahrung mit Kivy haben.

Ich würde mich unfassbar über jede Antwort freuen. Auch wenn ich weiß, dass ich schon öfter gefragt habe😁. Aber ich muss mich halt erst mal da reinarbeiten.

Viele Grüße

Code Snake🙂

programmieren, Programmiersprache, Python, Python 3, Objektorientierte Programmierung
2 Antworten
CodeSnake
17.05.2023, 19:26
Beitrag wurde 1 Mal erneut eingestellt
Wozu das super()-__init__(**kwargs)?

Bei dem Code im Anhang, der Hangman als Python App mit dem Kivy Framework erstellt, weiß ich nicht wozu man die Zeile mit dem super() braucht. Also warum muss man die **kwargs Argumente an die Basisklasse weitergeben?

class HangmanGame(BoxLayout):    
    def __init__(self, **kwargs):
            super().__init__(**kwargs)
            self.word_list = ["python", "java", "ruby", "javascript", "php"]
            self.guess_word = []
            self.secret_word = ""
            self.remaining_guesses = 6
        self.img_path = "img/hangman_{}.png"
        self.create_game_layout()
        self.new_game()


    def create_game_layout(self):
        self.orientation = "vertical"
        self.image = Image(source=self.img_path.format(0))
        self.word_label = Label(text=" ".join(self.guess_word),
                                font_size="50sp",
                                halign="center",
                                valign="middle")
        self.remaining_guesses_label = Label(text=f"Remaining guesses: {self.remaining_guesses}")
        self.input_label = Label(text="Enter a letter:")
        self.input = TextInput(multiline=False)
        self.submit_button = Button(text="Submit", 

#Hier fehlt was unwichtiges, weil die Frage zu lang war

    def new_game(self):
        self.secret_word = random.choice(self.word_list)
        self.guess_word = ["_"] * len(self.secret_word)
        self.remaining_guesses = 6
        self.image.source = self.img_path.format(0)
        self.input.text = ""
        self.word_label.text = " ".join(self.guess_word)
        self.remaining_guesses_label.text = f"Remaining guesses: {self.remaining_guesses}"


    def check_letter(self, instance):
        letter = self.input.text
        if letter in self.secret_word:
            for i, c in enumerate(self.secret_word):
                if c == letter:
                    self.guess_word[i] = letter
            if "_" not in self.guess_word:
                self.end_game(True)
        else:
            self.remaining_guesses -= 1
            self.image.source = self.img_path.format(6 - self.remaining_guesses)
            self.remaining_guesses_label.text = f"Remaining guesses: {self.remaining_guesses}"
            if self.remaining_guesses == 0:
                self.end_game(False)
        self.input.text = ""
        self.word_label.text = " ".join(self.guess_word)


    def end_game(self, victory):
        message = "Congratulations, you won!" if victory else f"Sorry, the word was {self.secret_word}."
        self.remaining_guesses_label.text = message
        self.remove_widget(self.input_label)
        self.remove_widget(self.input)
        self.remove_widget(self.submit_button)
        self.add_widget(Button(text="New Game", on_press=self.new_game))



class HangmanApp(App):


    def build(self):
        Window.clearcolor = (0.5, 0.5, 0.5, 1)
        return HangmanGame()


HangmanApp().run()
programmieren, Python, Instanz, Python 3, Objektorientierte Programmierung
2 Antworten
CodeSnake
13.05.2023, 15:57
Beitrag wurde 1 Mal erneut eingestellt
Warum werden in diesem Code Klassen verwendet?

Also was für einen Vorteil hat das?:

Der Code ist für ein Tic-Tac-Toe-Spiel

class Board():
    def __init__(self):
        self.state = [0, 0, 0, 0, 0, 0, 0, 0, 0]

    def make_turn(self, cell, player):
        if self.is_valid_turn(cell):
            self.state[cell] = player.symbol
            return True
        return False

    def is_valid_turn(self, cell):
        if self.state[cell] == 0:
            return True
        else:
            return False

    def check_win(self, player):
        s = player.symbol
        if self.state[0] == s and self.state[1] == s and self.state[2] == s:
            return True
        elif self.state[3] == s and self.state[4] == s and self.state[5] == s:
            return True
        elif self.state[6] == s and self.state[7] == s and self.state[8] == s:
            return True

        elif self.state[0] == s and self.state[3] == s and self.state[6] == s:
            return True
        elif self.state[1] == s and self.state[4] == s and self.state[7] == s:
            return True
        elif self.state[2] == s and self.state[5] == s and self.state[8] == s:
            return True

        elif self.state[0] == s and self.state[4] == s and self.state[8] == s:
            return True
        elif self.state[2] == s and self.state[4] == s and self.state[6] == s:
            return True

    def is_full(self):
        for i in self.state:
            if i == 0:
                return False
        return True

    def sign_to_printable(self, sign):
        if sign == 0:
            return " "
        elif sign == 1:
            return "X"
        else:
            return "O"

    def print_board(self):
        print(" " + self.sign_to_printable(self.state[0]) + " | " + self.sign_to_printable(self.state[1]) + " | " + self.sign_to_printable(self.state[2]) + " \n" +
              " " + self.sign_to_printable(self.state[3]) + " | " + self.sign_to_printable(self.state[4]) + " | " + self.sign_to_printable(self.state[5]) + " \n" +
              " " + self.sign_to_printable(self.state[6]) + " | " + self.sign_to_printable(self.state[7]) + " | " + self.sign_to_printable(self.state[8]) + " \n")


class Player:
    def __init__(self, symbol):
        self.symbol = symbol


if __name__ == '__main__':
    player_a = Player(1)
    player_b = Player(-1)
    board = Board()
    active_player = player_a
    while not board.is_full():
        board.print_board()
        try:
            cell = int(input("Where do you want to place your sign? [1-9]"))
        except ValueError:
            continue
        cell = cell - 1
        if cell < 0 or cell > 8:
            print("Please enter a number between 1 and 9")
            continue
        if not board.make_turn(cell, active_player):
            print("Invalid Move")
            continue

        if board.check_win(active_player):
            print("You wonnered! GW.")
            break

        if …
IT, programmieren, Informatik, Programmiersprache, Python, Instanz, Python 3, Objektorientierte Programmierung
2 Antworten
CodeSnake
05.05.2023, 19:16
Beitrag wurde 1 Mal erneut eingestellt
Python Referenzen und Objektkopien?

ChatGPT und mein Pythonbuch sagen folgendes:
„In Python werden Objekte durch Referenzen verwaltet, die auf den Speicherbereich zeigen, in dem das Objekt gespeichert ist. Wenn ein Objekt über eine Referenz zugewiesen wird, wird der Speicherplatz für das Objekt reserviert und die Referenz zeigt auf diesen Speicherbereich. Wenn auf denselben Wert bereits von einer anderen Referenz verwiesen wird, zeigt diese Referenz auf dasselbe Objekt/Speicherbereich.“

Aber danach steht in meinem Pythonbuch der Code am Ende dieser Nachricht.
Und über dem Code stand, dass mit diesem y.append(i) eine echte Kopie von x erstellen kann. Aber da ja schon x auf die Liste verweist hätte man nach dem .append() ja zwei Referenzen. Nämlich x und y. Also müsste Python laut der ersten Aussage doch mit beiden Referenzen auf ein und dasselbe Objekt verweisen. Dann wäre es aber keine Kopie mehr, sondern das gleiche Objekt.

Ich hoffe, dass ich mein Problem irgendwie erklären konnte.
LG Code Snake 🙂

import copy

x = [23, "hallo", -7.5]
y = []

for i in x:
    y.append(i)

print("dasselbe Objekt:", x is y)
print("gleicher Inhalt:", x == y)
print()

x = (23, ["Berlin", "Hamburg"], -7.5, 12.67)
y = copy.deepcopy(x)

print("dasselbe Objekt:", x is y)
print("gleicher Inhalt:", x == y)
IT, programmieren, Informatik, Programmiersprache, Python, Referenz, Python 3, Objektorientierte Programmierung
3 Antworten
CodeSnake
07.04.2023, 16:18
**kwargs in __init__() Methode und "self" in Python?

Hey Leute,

ich habe heute begonnen, Kivy zu lernen. Kivy ist ein Python Framework, für plattformübergreifende Apps. Ich bin allerdings noch ein Anfänger in Python und da man für Kivy OOP beherrschen muss. Habe ich mir eben ein paar Tutorials angeschaut und das Konzept von Klassen auch verstanden und schon etwas geübt. Auch das "self" eine Referenz auf die aktuelle Instanz ist habe ich kapiert. Aber wieso kann man aus einer Methode auf die Instanzvariablen nur zugreifen, wenn vor diesen "self" steht?

Und meine zweite Frage ist, wozu bei der Initialisierung der __init__() Methode manchmal noch so ein **kwargs steht. Also hier mal ein Beispielcode:

class MyGrid(GridLayout):

  def __init__(self, **kwargs):

    super().__init__(**kwargs)

    self.word_list = ["python", "java", "ruby", "javascript"]

    self.guess_word = []

    self.secret_word = ""

    self.remaining_guesses = 6

    self.img_path = "img/hangman_{}.png"

    self.create_game_layout()

    self.new_game()

Das ist jetzt mal nur die __init__() Methode einer MyGrid Klasse die von GridLayout erbt.

Ach ja. Was dieses "super()" bedeutet habe ich auch nicht so ganz verstanden.

Ich wäre sehr sehr dankbar wenn mir jemand helfen könnte. Denn ich will für eine Projektarbeit im Informatikunterricht umbedingt eine Android Kivy App für Hangman programmieren. Aber dafür muss ich diese Themen erst einmal verstehen.

LG Code Snake

Programmiersprache, Python, Instanz, Python 3, Objektorientierte Programmierung, App Programmieren
3 Antworten
KathaHohenfels
10.04.2022, 16:19
Wie stelle ich mithilfe compareTo() die natürliche Objektreihenfolge her (Java)?

Ich habe heute über die compareTo()-Methode des Comparable-Interfaces gelesen, man würde sie wie folgt verwenden:

"If your class objects have a natural order, implement the 

Comparable<T>

 interface and define this method."

Aber wie kann ich compareTo() implementieren, um die natürliche Reihenfolge der Objekte herzustellen?

Beispiel: Ich sollte Studenten nach ihrer Punktzahl sortieren, habe dann compareTo() wie folgt überschrieben:

@Override
public int compareTo(Student student) {
    if(this.points > student.points)
        return 1; //current student is better
    return 0;
}

Allerdings returnt das ja jetzt nur einen bestimmten Wert, mit dem man dann arbeiten könnte, wenn man anschließend die Studenten z.B. in eine Liste packen will, aber es stellt ja nicht bereits in der Methode selbst die Objektreihenfolge her. Ich verstehe auch gar nicht, wie das gehen soll, wenn ich z.B. will, dass die Klasse Student das Interface Comparable implementiert. Ich meine, wenn ich dann ein Objekt erzeuge, dann kann ich auf dieses und ein anderes diese Methode anwenden, aber ich bräuchte ein weiteres Hilfsmittel, um die Studenten zu ordnen, wie eben z.B. besagte Liste.

Ist es also irgendwie möglich, compareTo() so zu überschreiben, dass es automatisch Studenten oder allgemein Objekte in ihre natürliche Reihenfolge bringt oder brauche ich dafür immer noch weitere Hilfsmittel?

Oder habe ich compareTo() auf richtige Weise überschrieben?

LG Kath

PS:
In der Doku steht ebenfalls Folgendes über Comparable():

This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method.

programmieren, Java, Informatik, Interface, Objektorientierte Programmierung
3 Antworten
Ruhrpotter4324
22.09.2021, 05:49
Wofür stehen die Parameter in __init__(self, ...) und super().__init__(...) in Python?

Hallo, ich lese mir in einem Buch gerade das Kapitel zu Klassen und Vererbung durch. Was ich bislang verstanden habe: Basisklassen kann man durch Tochterklassen im Stil Tochterklasse(Basisklasse) kopieren und anschliessend weiterentwickeln (Vererbung).

Dabei gibt man der Tochterklasse mit __init__(self, ...) ihren eigenen Konstruktor und damit der Codeverlauf konsistent bleibt, fügt man in der anschliessenden Zeile super().__init__( ...) hinzu. Anschliessend kann man Methoden der Basisklasse überschreiben. Bei einfachen Beispielen fand ich das nachvollziehbar.

Nun habe ich ein komplizierteres Beispiel vor, bei dem in den jeweiligen Klammern noch weitere Parameter stehen (sowohl bei dem neuen als auch alten Konstruktor), das sieht wie folgt aus:

#Tochterklasse der Basisklasse VerwalteterGeldbetrag

class AllgemeinesKonto(VerwalteterGeldbetrag):

  def __init__(self, kundendaten, kontostand):

    super().__init__(kontostand)

self.Kundendaten = kundendaten

Frage: Wofür genau stehen Werte wie diese in den Klammern, was machen sie? Gemeint sind die ab def. Da der Gesamtcode über 80 Zeilen oder so lang ist, habe ich nur diese beiden Inhalte eingefügt, um die Frage abstrakt zu halten. Was objektorientierte Programmierung ist, habe ich grob verstanden, nur sind da so viele Schritte, auf die ich als kompletter Anfänger nicht so schnell kommen würde.

Computer, programmieren, Informatik, Python, Objektorientierte Programmierung
2 Antworten
EmptyVoid
09.03.2020, 12:55
Mit Links
"<objekt>": Unbekannter Überschreibungsspezifierer [C++ | Visual Studio Community]?

Hallo, lieber Leser,

leider gelingt es mir partout nicht, Objektinstanzen innerhalb von Klassen weiter zu verwenden und ich befürchte, dass ich etwas Grundlegendes im Konzept der OOP übersehe bzw. nicht kenne.

In einem kleinen Freizeitprojekt von mir werden, was Beweggrund für diesen Post hier war, leider eine Reihe von Fehlern ausgespuckt, für die zu lösen zu versuchen ich schon eine Menge Zeit aufgewandt habe und welche ich alle auf eine Unkenntnis eines wichtigen Konzeptes, wie oben schon beschrieben, zurückführe.

Ich würde mich über konkrete Lösungsvorschläge genauso freuen, wie auf Hinweise, was ich wohl konzeptuell nicht so recht verstanden habe. Vielen Dank.

main.cpp: https://pastebin.com/PKCF75FR

Fehler: Schweregrad Code Beschreibung Projekt Datei Zeile Unterdrückungszustand

Fehler C3646 "difficulty": Unbekannter Überschreibungsspezifizierer C:\Users*\source\repos*\main.cpp 9

Fehler C3646 "getDifficulty": Unbekannter Überschreibungsspezifizierer C:\Users*\source\repos*\main.cpp 20

Fehler C2065 "Item": nichtdeklarierter Bezeichner C:\Users*\source\repos*\main.cpp 76

Fehler C3646 "playerClass": Unbekannter Überschreibungsspezifizierer C:\Users*\source\repos*\main.cpp 73

Fehler C2923 "std::vector": "Item" ist kein gültiges Vorlage-Typargument für den _Ty-Parameter. C:\Users*\source\repos*\main.cpp 76

Fehler C4430 Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt. * C:\Users*\source\repos*\main.cpp 73

Fehler C2059 Syntaxfehler: "(" C:\Users*\source\repos*\main.cpp 20

Fehler C2059 Syntaxfehler: "=" C:\Users*\source\repos*\main.cpp 9

Fehler C2238 Unerwartete(s) Token vor ";" C:\Users*\source\repos*\main.cpp 9

Fehler C2334 Unerwartete(s) Token vor "{"; sichtbarer Funktionstext wird übersprungen C:\Users*\source\repos*\main.cpp 20

Fehler C1903 Weiterverarbeitung nach vorherigem Fehler nicht möglich; Kompilierung wird abgebrochen. C:\Users*\source\repos*\main.cpp 76

Grundlegende Fehler, also noch grundlegender, als die oben beschriebenen, dürfen ignoriert werden.

Computer, programmieren, CPP, Informatik, Visual Studio, Objektorientierung, Objektorientierte Programmierung
2 Antworten
Jensek81
18.01.2019, 18:08
Mit Bildern
UML Diagramm in Python umsetzen?

Chrutschow. Nachdem mein Versuch, vorgegebene Datentypen in ein Klassendiagramm zu schreiben, bemerkenswert kläglich scheiterte, heute nun the-other-way-round: Ein UML Diagramm in Python umsetzen:

Insbesondere frage ich mich, wie bei der Implementierung zwischen Vererbung, Aggregation und gerichteten Assoziationen unterschieden wird. Scheinbar gibt es dafür 2000 Tutorials mit 30000 unterschiedlichen Lösungsansätzen. Außerdem weiß ich nicht, was genau die einzelnen Objekte tun. Zum Beispiel steht beim Professor nur Kostencenternummer als geschützte Variable. Und der WiMi macht anscheinend gar nichts. Was schreibe ich in die Getter und Setter?

Hier der bisherige Ansatz:

######Vererbung
"""This programm models the UML diagram of the inheritante between
members and professors.
"""
class Member:
  name = ""

  def __init__(self, name, id_number):
    self.name = name
    self.id_number = id_numer

class Professor(Member):
  def __init__(self, name, id_number, cost_center_no):
    self.name = name
    self._cost_center_no = _cost_center_no

  def get_cost_center_no(self):
    # Wie Kostenstellennummer umsetzen?

class WiMi(Member):
  def __init__(self, name, id_number):
    self.name = name

Aggregation

class Presentation:
  def __init__ (self, title, date):
    self.title = name
    self.date = date

  def change_date(self):
    print ("Class Owner: method1")

Gerichtete Assoziation

class research_group:
  def __init__(self, name, total_presentation):
    self.name = name
    self.total_presentation = total_presentation
    self.name = name

  def get_members(id_number, name, total_representation):
  
  def get_head (id_number, name, total_reprensentation)

  def set_head (id_number, name, total_reprensentation)

  def add_member (id_number, name, total_representation)

  #Was machen diese Methoden?
Bild zum Beitrag
programmieren, Informatik, Python, UML, Klassendiagramm, Objektorientiert, Objektorientierte Programmierung, OOP Programmierung
1 Antwort
Jensek81
16.01.2019, 19:49
Klassen- und Objektdiagramme in UML?

Hallo Leute,

normalerweise hasse ich es, wenn man so lächerlich einfache Fragen, die sich mit zwei Minuten googeln selbst beantwortet, stellt, aber ich komme nach zwei Tagen Recherche immer noch nicht auf den Trichter:

Aufgabe:

Erstellen Sie ein UML-Diagramm für folgende, sowie eine weitere übergeordnete Klasse mit den gegebenen Attributen und Methoden. Geben Sie in ihrem UML-Diagramm auch Konstruktoren an. Passen Sie die Namen an, beachten Sie hierbei PEP 8.Erzeugen Sie eine sinnvolle Vererbungshierarchie zwischen den Klassen.

Hinweis: Überlegen Sie genau, was die angegebenen Klassen verbindet.

Angestellter

• Personalnummer

• Name

• Adresse

• Geburtsdatum

• Gehalt

• Bankverbindung

• DruckeAdresse()

• ÜberweiseGehalt()

Student

•Matrikelnummer

•Name

•Adresse

•Geburtsdatum

•DruckeAdresse()

•DruckeAusweis()

Hilfskraft

• Matrikelnummer

• Name

• Adresse

• Geburtsdatum

• Personalnummer

• Beschäftigungsart

• DruckeAdresse()

• DruckeAusweis()

• DruckeArbeitszeiten()

Erstellen Sie zwei Objektdiagramme, welche dieses Klassendiagramm erfüllen. Generieren Sie die erforderlichen Objektwerte

Mein Ansatz/Problem: Die eigenen Klassen interagieren doch überhaupt nicht miteinander? Die einzige Vererbung findet zwischen Stundeten und Hilfskraft statt. Selbst die Hilskraft bekommt noch nicht mal Gehalt. Wie soll man das in einem UML-Diagramm verbinden? Und soll man als Objektdiagramm dann einfach nur 8 Kästchen malen, ohne Pfeile?

Schule, programmieren, Informatik, UML, Klassendiagramm, Vererbung, Objektorientierte Programmierung, OOP Programmierung
3 Antworten

Meistgelesene Beiträge zum Thema Objektorientierte Programmierung
Mehr meistgelesene Fragen zu Objektorientierte Programmierung