Python – die neusten Beiträge

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

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

Python: Wieso wird bei diesem Skript keine Rückmeldung angezeigt?

Ich wollte nur fragen, was an diesem Python-Skript falsch ist. Es wird nur keine Rückmeldung angezeigt:

import pygame

# Initialisierung von Pygame
pygame.init()

# Fenstergröße festlegen
window_width = 800
window_height = 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Plattform-Spiel")

# Farben definieren
black = (0, 0, 0)
white = (255, 255, 255)

# Spielergröße und Position
player_width = 50
player_height = 50
player_x = window_width // 2 - player_width // 2
player_y = window_height - player_height

# Spielerbewegung
player_x_speed = 0
player_y_speed = 0
player_jump_power = -10
gravity = 0.5

# Plattformgröße und Position
platform_width = 200
platform_height = 20
platform_x = window_width // 2 - platform_width // 2
platform_y = window_height - platform_height - 50

# Hauptspielschleife
running = True

while running:
  window.fill(white)

  # Ereignisse verarbeiten
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
    elif event.type == pygame.KEYDOWN:
      if event.key == pygame.K_LEFT:
        player_x_speed = -5
      elif event.key == pygame.K_RIGHT:
        player_x_speed = 5
      elif event.key == pygame.K_SPACE:
        if player_y == window_height - player_height:
          player_y_speed = player_jump_power
    elif event.type == pygame.KEYUP:
      if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
        player_x_speed = 0

  # Spielerbewegung aktualisieren
  player_x += player_x_speed
  player_y += player_y_speed
  player_y_speed += gravity

  # Kollisionserkennung mit Plattform
  if player_y + player_height >= platform_y and player_y_speed >= 0:
    if player_x + player_width >= platform_x and player_x <= platform_x + platform_width:
      player_y = platform_y - player_height
      player_y_speed = 0

  # Spieler zeichnen
  pygame.draw.rect(window, black, (player_x, player_y, player_width, player_height))

  # Plattform zeichnen
  pygame.draw.rect(window, black, (platform_x, platform_y, platform_width, platform_height))

  # Fenster aktualisieren
  pygame.display.flip()

# Pygame beenden
pygame.quit()
Python, Python 3, Pygame

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

Python Fehler no attribute 'TFE_NewContextOptions'?

Hi, Ich habe einen Fehler beim ausführen von einem Python Script:

C:\Users\DeneX\Desktop\SC_FEGAN\SC-FEGAN-program-files>python demo.py

Traceback (most recent call last):

 File "C:\Users\DeneX\Desktop\SC_FEGAN\SC-FEGAN-program-files\demo.py", line 11, in <module>

   from model import Model

 File "C:\Users\DeneX\Desktop\SC_FEGAN\SC-FEGAN-program-files\model.py", line 1, in <module>

   import tensorflow as tf

 File "C:\Users\DeneX\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\LocalCache\local-packages\Python311\site-packages\tensorflow\__init__.py", line 24, in <module>

   from tensorflow.python import pywrap_tensorflow # pylint: disable=unused-import

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

 File "C:\Users\DeneX\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\LocalCache\local-packages\Python311\site-packages\tensorflow\python\__init__.py", line 49, in <module>

   from tensorflow.python import pywrap_tensorflow

 File "C:\Users\DeneX\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\LocalCache\local-packages\Python311\site-packages\tensorflow\python\pywrap_tensorflow.py", line 58, in <module>

   from tensorflow.python.pywrap_tensorflow_internal import *

 File "C:\Users\DeneX\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\LocalCache\local-packages\Python311\site-packages\tensorflow\python\pywrap_tensorflow_internal.py", line 96, in <module>

   TFE_NewContextOptions = _pywrap_tensorflow_internal.TFE_NewContextOptions

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

AttributeError: module '_pywrap_tensorflow_internal' has no attribute 'TFE_NewContextOptions'

Wie bekomme ich das behoben; Ich habe tensorflow==1.13.0rc2 installiert damit das Script läuft & Python 3.11.3

Linux, Programmiersprache, Python, Python 3, Pygame, Tkinter, Pycharm, Discord, Discord Bot

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

Wie kann ich eine Python Methode in einen int() umwandeln?

Ich schreibe aktuell an einem Python Code, dass mir die Uhrzeit anzeigen soll:

from tkinter import *
from time import *

Fenster = Tk()
Fenster.geometry(str(Fenster.winfo_screenwidth())+"x"+str(Fenster.winfo_screenheight()))
Fenster.title("Funktionen")

def Aktuelle_Zeit():
    Label(text = strftime("%H:%M:%S", localtime(time()))).place(x = int(Fenster.winfo_screenwidth)/4, y = int(Fenster.winfo_screenheight)/4)
Button(text = "Aktuelle Zeit", command = Aktuelle_Zeit).place(x = int(Fenster.winfo_screenwidth())/6*5, y = int(Fenster.winfo_screenheight()/20))


mainloop()

Jetzt kommt der Fehler:

Exception in Tkinter callback
Traceback (most recent call last):
 File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.11_3.11.752.0_x64__qbz5n2kfra8p0\Lib\tkinter\__init__.py", line 1948, in __call__
  return self.func(*args)
      ^^^^^^^^^^^^^^^^
 File "e:\Programmieren\New.py", line 10, in Aktuelle_Zeit
  Label(text = strftime("%H:%M:%S", localtime(time()))).place(x = int(Fenster.winfo_screenwidth)/4, y = int(Fenster.winfo_screenheight)/4)
                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: int() argument must be a string, a bytes-like object or a real number, not 'method'

Ich denke: Das heißt, dass ich eine Methode in einen integer umwandeln möchte, das aber nicht geht.

Das Label soll aber hinter einem Viertel des Bildschirms plaziert werden. Deswegen nehme ich die Bildschirm Größe und teile sie durch 4. Wie kann ich das Ganze sonst machen, ohne das ein Fehler kommt? Würde mich bei einer Antwort freuen.

Euer Alex

Computer, Programmiersprache, Python, Zeit, Python 3

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

Wie habt ihr Programmieren gelernt oder würdet es tun?

Die Frage richtet sich an Menschen, die nicht Informatik studiert haben, oder davor schon programmieren konnten. Wie habt ihr Programmieren gelernt oder würdet es angehen, wenn ihr euch jetzt dafür entscheiden würdet?

1. Durch das Lesen von Büchern und Tutorials: Eine Möglichkeit Programmieren zu lernen, ist durch das Studium von Büchern und Online-Tutorials (lesen). Indem man die Theorie und Beispiele lernt, kann man grundlegende Kenntnisse erwerben.

2. Durch das Anschauen von Online-Kursen und -Videos: Man kann auch Online-Kurse und -Videos ansehen, um Programmiersprachen und -konzepte zu erlernen. Durch das Ansehen von Videos kann man Konzepte besser verstehen und den Experten beim Programmieren über die Schulter schauen. Dazu gibt es ja auch kostenloses Material auf Youtube oder günstiges auf Udemy.

3. Mit einem Spiel: Eine unterhaltsame Möglichkeit, Programmierung zu erlernen, ist durch das Spielen von Spielen, die speziell dafür entwickelt wurden, Programmierfähigkeiten zu vermitteln. Da gibt es auch gute kostenlose Angebote. Ein Beispiel ist Scriptfighter, bei dem man Javascript lernt, indem man seinen Code gegen den Standardcode oder den Code eines anderen Spielers antreten lässt. Dieser wird dann von der Figur ausgeführt.Mit solchen Spielen kann man spielerisch Kenntnisse erwerben und seine Fähigkeiten vertiefen.

4. Einen Kurs besuchen: Eine weitere Möglichkeit, Programmierung zu erlernen, ist durch den Besuch von Kursen. der Vorteil hier wäre definitiv, dass man Fragen stellen kann und an praktischen Übungen teilnimmt. Kurse sind eine gute Möglichkeit, gezielt Kenntnisse in einer Programmiersprache oder einem Konzept zu erwerben und eine strukturierte Herangehensweise an das Lernen zu bekommen. Dafür muss man hierfür tiefer in die Tasche greifen.

Durch das Lesen von Büchern und Tutorials (lesen) 67%
Einen Kurs besuchen 17%
Durch das Anschauen von Online-Kursen und -Videos 13%
Mit einem Spiel 4%
HTML, programmieren, Java, JavaScript, Programmiersprache, Python

Wie bei Python mit "If" überprüfen ob Variable mit bestimmten Wert in Liste enthalten ist?

Ich muss für die Schule ein Spiel in Python programmieren. Problem dabei: Uns wurde noch nicht wirklich viel beigebracht und daher verstehe ich nicht, wie ich gewisse Sachen programmieren soll.

Folgendes Szenario bereitet mir nun Schwierigkeiten:

Das Programmierte ist kein Ausschnitt aus meinem Spiel, sondern einfach das gleiche Schema, wie die eine Stelle in meinem Spiel (sonst wäre es zu kompliziert zum verstehen). x hat z.B nicht immer den Wert 5, dieser ändert sich im Verlaufe des Programms.

Ich möchte überprüfen, ob eine der Variable in der Liste einen Wert zwischen 0 und 10 hat. Ist es möglich, dies mit einem "if" Befehl zu lösen? Was müsste bei "Bedingung_erfüllendes_Element" stattdessen stehen? Ich kann da ja nicht ">=0 and <=10" hinschreiben. Das einzige, was ich überprüfen kann, ist ob eine bestimmte Variable in der Liste ist. (z.B if x in liste), aber das möchte ich ja nicht, ich möchte auf den WERT der vorhandenen Variablen überprüfen.

Ich habe es auch schon mit einer For-Schleife probiert, aber da ist da Problem, dass wenn zwei Elemente, welche die Bedingung erfüllen, vorkommen, dass die folgenden Befehle doppelt ausgeführt werden. Es soll aber, für jedes Element, welches die Bedingung erfüllt, ein anderer Text geprintet werden.

Ich brauche wirklich nur diesen einen, eigentlich simplen Befehl, der überprüft, ob es in der Liste mindestens ein Element hat, welches einen bestimmten Wert hat.

Bild zum Beitrag
programmieren, Informatik, Programmiersprache, Python

Meistgelesene Beiträge zum Thema Python