Python: Instanz von einer Instanz einer Klasse erstellen?

Einfaches Beispiel:

class Tier:
  def __init__(self, name, alter):
    self.name = name
    self.alter = alter

hund = Tier('Hund', 14)
katze = Tier('Katze', 12)

Ich möchte jetzt mehrere Hunde haben.

Natürlich kann man eine extra Funktion schreiben und return Tier('Hund', 14) einsetzen, geht das jedoch irgendwie kürzer? (Da ich sehr viele verschiedene "Tiere" habe)

Danke im Vorraus!

3 Antworten

Vom Fragesteller als hilfreich ausgezeichnet

xxxcyberxxx

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

programmieren, Python, Programmieren & Softwareentwicklung

06.04.2022, 21:44

geht das jedoch irgendwie kürzer

Du könntest eine List Comprehension nutzen, um eine Liste voller Hunde zu erstellen. Hier sind jetzt alle mal mit namen "Hund" und Alter 14 und es gibt insgesamt 10 Hunde, das lässt sich aber noch anpassen:

dogs = [Tier('Hund', 14) for _ in range(10)]

alternativ eine klassische Schleife nutzen:

dogs = []
for _ in range(10):
  dogs.append(Tier('Hund', 14))

Woher ich das weiß:Studium / Ausbildung – Abgeschlossenes Studium der Informatik (B.Sc.)

KarlRanseierIII

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Computer, programmieren, Python

06.04.2022, 21:49

Mir ist die Frage nicht klar, Erst fragst Du nach Instanz von Instanz. Aber anscheinend geht es Dir eher um die Instanziierung vieler Objekte.

Für letzteres braucht es natürlich irgend eine Form von Datenquelle, aber prinzipiell könntest Du diese Daten auch als Tupel von Tupeln vorgeben. Jedes Tupel enthält dann die Parameter des Instanzaufrufs.

regex9

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Computer, programmieren, Python

06.04.2022, 21:44

Wenn die Tiere stets dieselben Eigenschaften haben, kannst du sie dir mit einer Schleife generieren lassen:

hunde = []
anzahl_hunde = 10

for index in range(anzahl_hunde):
  hunde.append(Tier("Hund", 14))

Wenn jedes Tier individuelle Eigenschaften hat, stellt sich die Frage, wer die individuellen Daten vorgibt. Vielleicht liegen sie in einer Datei vor. Dann kann man den Prozess erneut mit einer Schleife automatisieren.

Ähnliche Fragen

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?

...zur Frage

Verstehe den Fehler kaum Python?

HI,

und zwar bin ich dabei eine Aufgabe zu machen, doch kommen nicht weiter was mache ich den falsch??

Leider verstehe ich den Ausgebenden Fehler kaum.

Mein Code:

class Figur:
    def __init__(self, name, farbe, durchmesser, kanten):
      
        self.name = name
        self.farbe = farbe
    
        
    def ausgabe(self):
        print("Die Figur", self.name, "hat folgende Eigenschaften:")
        print("Die Figur hat die Farbe:", self.farbe)
        
        
    def Radius_Veraendern(self, veraendern):
      if self.radius < 1:
          self.radius = self.radius + 1
          print("Der neue Radius beträgt", self.radius)
          
          
    def Kante_Veraendern(self, veraendern):
      if self.kantenlaenge < 1:
          self.kantenlaenge = self.kantenlaenge + 6
          print("Die nue KAntenlänge brträgt", self.kantenlaenge)
          
          
    def Laenge_Veraendern(self, veraendern):
        if self.laenge < 1:
           self.laenge = self.laenge + 3
           print("Die neue Linienlänge beträgt:", self.laenge)
           
        
# Die Klasse für Kreis
class Kreis(Figur):
    def __init__(self, name, farbe, radius):
        super().__init__(name, farbe, radius)
        
        self.radius = radius
       
 
    def ausgabe(self):
        super().ausgabe()
        print("Der Radius beträgt:", self.radius)
        
        
#Die Klasse für Viereck
class Viereck(Kreis):
    def __init__(self, name, farbe, kantenlaenge):
        super().__init__(name, farbe, kantenlaenge)
        
        self.kantenlaenge = kantenlaenge
        
    def ausgabe(self):
        super().ausgabe()
        print("Die Kantenlänge beträgt:", self.kantenlaenge)
        
       
# Die Klasse für Linie
class Linie(Kreis):
    def __init__(self, name, farbe, laenge):
        super().__init__(name, farbe, laenge)
        
        self.laenge = laenge
        
    def ausgabe(self):
        super().ausgabe()
        print("Die Linienlänge beträgt:", self.laenge)
        
    
    


#einen Kreis erzeugen
kreis = Kreis("Mein Kreis", "Rot", 5)
kreis.ausgabe()
#verändere den Wert
kreis.Radius_Veraendern(-5)


print("----------------")


#ein Viereck erzeugen
viereck = Viereck ("Mein Viereck", "Blau", 8)
viereck.ausgabe()
#verändere den Wert
viereck.Kante_Veraendern8(-10)


print("----------------")




#eine Linie erzeugen
linie = Linie("Meine Linie", "Grün", 9)
linie.ausgabe()
#verändern den Wert
viereck.Linie_Veraendern(-8)

...zur Frage

Mein Python Code funktioniert nicht?

Guten Abend erst einmal,

ich habe versucht mittels Python ein Mau Mau spiel zu erstellen, aber wenn ich es ausprobieren will, zeigt mir das Programm mitten im code " invalid Syntax " an.

Kann einer von euch mal bitte drüber schauen und mir sagen, was fehlt?

Hier ist der Code (,was mir als Fehler angezeigt wurde habe ich markiert( es ist das deck.shuffel ())).

import random

class Card:

def __init__(self, value, suit):

self.value = value

self.suit = suit

def __repr__(self):

return f"{self.value} of {self.suit}"

class Deck:

suits = ["Hearts", "Diamonds", "Spades", "Clubs"]

values = ["Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"]

def __init__(self):

self.cards = [Card(value, suit) for suit in self.suits for value in self.values]

def shuffle(self):

random.shuffle(self.cards)

def deal(self):

return self.cards.pop()

class Player:

def __init__(self, name):

self.name = name

self.hand = []

def draw(self, deck):

self.hand.append(deck.deal())

def play_card(self, card):

self.hand.remove(card)

class AIPlayer(Player):

def choose_card(self, top_card):

for card in self.hand:

if card.value == top_card.value or card.suit == top_card.suit:

return card

return self.hand[0]

def play_game():

deck = Deck()

... deck.shuffle()

...

... player = Player("Player")

... ai = AIPlayer("AI")

...

... for i in range(7):

... player.draw(deck)

... ai.draw(deck)

...

... top_card = deck.deal()

...

... while len(player.hand) > 0 and len(ai.hand) > 0:

... print(f"Top card: {top_card}")

... print(f"{player.name}'s hand: {player.hand}")

...

... chosen_card = player.play_card(player.hand[int(input("Choose a card to play (index): "))])

... if chosen_card.value == top_card.value or chosen_card.suit == top_card.suit:

... top_card = chosen_card

... else:

... player.draw(deck)

... print(f"{player.name} drew a card.")

...

... if len(ai.hand) > 0:

... chosen_card = ai.choose_card(top_card)

... print(f"{ai.name} played {chosen_card}.")

... if chosen_card.value == top_card.value or chosen_card.suit == top_card.suit:

... top_card = chosen_card

... else:

... ai.draw(deck)

... print(f"{ai.name} drew a card.")

...

... if len(player.hand) == 0:

... print(f"{player.name} wins!")

... else:

... print(f"{ai.name} wins!"

>>> [DEBUG ON]

>>> [DEBUG OFF]

...zur Frage

**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

...zur Frage

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()

...zur Frage

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 …

...zur Frage

Wie ist dieser Code in Python zu verstehen (Fibonacci-Rechner)?

Hallo, ich sehe mir gerade einen Python-Code zur Berechnung der Fibonacci-Zahlen an und verstehe folgenden Teil nicht: self.A, self.B = self.B, self.A + self.B - wie genau wird das mathematisch berechnet? Wie genau man die Fibonacci-Zahlen mathematisch berechnet, verstehe ich, aber wie genau das in diesem Code funktioniert, ist mir schleierhaaft. Was bezweckt denn self.B hinter der Klammer? Und warum hat self.B in __iter__(self) den Wert 1?

class Fibonacci:
    def __init__(self, max_n):
        self.MaxN = max_n #Legt das Endelement fest, bei dem Berechnung stoppen soll!
        self.N = 0 #Zählt, wie viele Elemente bereits zurückgegeben wurden
        self.A = 0 
        self.B = 0
    def __iter__(self):
        self.N = 0
        self.A = 0
        self.B = 1
        return self
    def __next__(self):
        if self.N < self.MaxN:
            self.N += 1
            self.A, self.B = self.B, self.A + self.B
            return self.A
        else:
            raise StopIteration

...zur Frage

Python Anfänger was heißt Args und Kwargs?

Ich habe mehrere Fragen

Wenn ich eine Klasse erstelle z.B

class Dog() was kann ich in dieser Klammer einsetzen bzw warum setzt man überhaupt etwas da ein?

Ich habe eine Methode innerhalb dieser Klasse erstellt z.B

def __init__ (self, Benutzer_ID ='Sicher', Alter)

Ich habe hier den Parameter Benutzer_ID einen Wert zugewiesen, normalerweise

darf man doch dies nicht tun. Die richtige Schreibweise sieht doch wie folgt aus oder?

class Dog()

def __init__ (self, Benutzer_ID , Alter)

self.Benutzer_ID = Benutzer_ID

Dog1 = Dog('Sicher',18)

3)Ich habe folgende Funktion > deff __init__(self, Benutzer_ID='Hey',' *args, **kwargs):

wofür steht das args und kwargs?

...zur Frage

Wie kann ich meinen Python-Code schneller machen?

Hallo,

ich habe gestern in Python ein paar Funktionen geschrieben, die mir ein interessantes Bild ausrechnen sollen. Ich kriege es jedoch nicht hin, dass das Programm einigermaßen schnell läuft und am Ende muss auch die Auflösung darunter leiden

Wenn da mal jemand drüberschauen könnte, wäre das wirklich hilfreich.

import numpy as np
import matplotlib.pyplot as plt
from math import pi, sqrt, atan

#Punkt definieren
class point:
    def __init__(self,x=0,y=0,z=0):
        self.x = x
        self.y = y

    #Operationen
    def __str__(self):
        return "({0},{1})".format(self.x, self.y)

    def __add__(self, other):
        return point(self.x+other.x,self.y+other.y)

    def __sub__(self, other):
        return point(self.x - other.x, self.y - other.y)

    def __abs__(self):
        return sqrt(self.x**2 + self.y**2)

    def __mul__(self, other):
        if type(other) == point:
            return point(self.x * other.x, self.y * other.y)
        return point(self.x * other, self.y * other)

    def __truediv__(self, other):
        if type(other) == point:
            return point(self.x / other.x, self.y / other.y)
        return point(self.x / other, self.y / other)

    def __neg__(self):
        return point(-self.x,-self.y)

# weitere Funktionen für Punkte
def dis(PointA,PointB):
    return abs(PointB-PointA)

def dir(PointA,PointB):
    return (PointB-PointA)/dis(PointA,PointB)


#Funktion für den Wert
def grav_v(x,y,time=5,frames=60):
    p = point(-1,0)
    sp = point(x+1,y)

    c = point(0,0)
    sc = point(0,0)
    
    #Vielleicht wegen des for-loops so langsam?
    for k in range(frames*time):
        try:
            plus = dir(p,c) * 1/dis(p,c)**2 / frames
            sp += plus
            p += sp/frames
            sc -= plus
            c += sc/frames
        except:
            pass

    return p


#Funktion für das Bild
def grav_c(a=-4, b=4, smoothness=1):
    ROWS = []
    p = 0
    print(0)
    #zwei for-loops...
    for Y in np.linspace(a,b,int(200*smoothness)):
        row = []
        for X in np.linspace(a,b,int(200*smoothness)):
            g = grav_v(X, Y)
            row.append( (abs(atan(g.x)*2/pi), abs(atan(g.y)*2/pi), abs(atan(abs(g))*2/pi)) )
        ROWS.append(row)
        p += 1
        print(p / (200 * smoothness))
    plt.imshow(ROWS, extent=(a, b, a, b))
    plt.show()

grav_c()

...zur Frage

Python Druckerwarteschlange?

class TDruckauftrag(object):
    def __init__(self, pName, pPrioritaet):
        self.__Name = pName
        self.__Prioritaet = pPrioritaet
    def gib_Name(self):
        return self.__Name
    def gib_Prioritaet(self):
        return self.__Prioritaet
    def setze_Prioritaet(self, pPrioritaet):
        self.__Prioritaet = pPrioritaet
    def __del__(self):
        del self.__Name
        del self.__Prioritaet

Das ist das Programm bis jetzt.

Nun soll man die fehlenden attribute und methoden der Klasse „TDruckauftrag“ ergänzen.

Was muss ich jetzt machen ich verstehe wirklich gar nix davon kann mir bitte wer helfen.

Bitte nicht mit machs selber kommen ich würde wenn ich könnte aber ich kann nicht

...zur Frage

Tic Tac Toe?

Ich möchte ein TTT in phyton programmieren hier ist mein quellcode ich weiß das er nicht fertig ist:
class  Board:
    def __init__(self):
        self.state = [0, 0, 0, 0, 0, 0, 0, 0, 0,]

        def make_turn(self, cell, player):
            self.state[cell] =  player.symbol

    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()

Jetzt bekomme ich ein paar fehlermeldungen :Expression expected, Unindent does not match any outer indentation level in zeile 20 und Unresolved reference 'Board' in der 28.WAS heißt das und wie kann ich das fixen

...zur Frage

Der Parameter "self" in Python in anderen Funktionen als __init__?

Hallo Leute, ich nochmal :)

Ich versuche mich gerade nach einer kurzen Pause wieder in Python und habe eine Frage zum Parameter self: anfangs dachte ich, dass dieser nur bei der Funktion __init__ gebraucht wird, welche jedes Mal aufgerufen wird, wenn eine neues Objekt erstellt wird. (Jetzt habe ich einen Code gefunden, der self auch in anderen Funktionen verwendet.)

Zurzeit weiß ich, dass self ein Objekt ist. Mit self.xx kann man Attribute bezogen auf self implementieren und ihnen Werte zuteilen. (zB self.id = xx)

Wenn ich jedoch (zB) eine neue Funktion in der Klasse schreibe, in der ich __init__ schon verwendet habe kommt bei dieser Funktion: def funktion(self, num): ... folgende Fehlermeldung, wenn ich sie mit (x=klassenname.funktion(3)) aufrufe: testsS.f2() missing 1 required positional argument: 'num'

Bei dem erstellen meines Objektes (wenn hier überhaupt ein Objekt erstellt wird) muss ich jedoch nur ein Argument eingeben, da ich bei __init__ self nicht deklarieren muss...

Ich bitte um kurze Hilfe, da ich leider wenig Antworten finde...

Danke,

...zur Frage

Python - Frage zu Klassen Methoden Objekten?

Hallo,

Ich habe eine kleines Problem mit Klassen bzw. dessen Objekten. Ich zeige mein Problem anhand eines kleinen Beispiels:

Initialisierung der Klasse:

class Test:
  def __init__(self, test_objekt):
    self.test-objekt = test_objekt
  
  def test_methode(self)
    print(self.test_objekt)

Die Klasse hat 3 Methoden die alle das test-objekt verwenden möchten.

Aber mir klappt die Übergabe von dem in __init__ initialisiertem test_objekt nicht auf die Methode. Wie muss ich es schreiben dass das self.test_objekt in der test_methode benutzt werden kann?

Aufruf der Klasse ist im Beispiel übertragen auf mein Problem:

Test.test_methode(test_objekt)

...zur Frage

Was bedeutet dieser "Type Error"?

Hi mal wieder. Ich sitze gerade an einem Programm, welches Temperaturen jeweils von und nach Kelvin, Celsius und Fahrenheit berechnet, bekomme jedoch die Fehlermeldung:

TypeError: __init__() missing 1 required positional argument: 'f'

Ich kann leider den Fehler nicht verstehen/finden und bitte darum, ob jemand eventuell drüberschauen könnte.

Mein Programm:

class Temperatur:    
    def __init__(self, c, k, f,): 
        self.c = c
        self.k = k
        self.f = f

def get_temperature(c):
    return c

def convert_to_celsius(k):
    c = k - 273,15
    return c

def convert_to_celsius(f):
    c = (f - 32) * 5/9
    return c

def setTemperature(t,c):
    if(c < 273,15):
        return False  
    else: 
        c = t
        return True

def get_temperature(k):
    return k

def convert_to_kelvin(c):
    k = c + 273.15
    return k

def convert_to_kelvin(f):
    k = (f-32) * (5/9) + 273,15
    return k

def setTemperature(t, k):
    if(k < 0):
        return False
    else: 
        k = t
        return True

def get_temperature(f):
    return f

def convert_to_fahrenheit(c):
    f = (c * 9/5) + 32
    return f

def convert_to_fahrenheit(k):
    f = (k - 273,15) * 9/5 + 32
    return f

def setTemperature(t, f):
    if(f < -459,67):
        return False
    else: 
        f = t
        return True

...zur Frage

Was möchtest Du wissen?

Deine Frage stellen