Python + Pyside2 oder einfach "Rechner"

Hallo Habr!

Ich heiße Sasha. Ich bin ein Junior-Entwickler. Ich arbeite als Software-Tester. Ich schreibe hauptsächlich Tests mit Python + Selen, aber Python wurde so interessant, dass ich mich damit beschäftigen und so viele Frameworks wie möglich lernen wollte! Ich wollte eine Desktop-Anwendung schreiben, ala einfachen "Rechner". Meine Wahl fiel auf Pyside2. Ich gebe nicht vor, den perfekten Code oder die perfekte Lektion zu haben. Es besteht einfach der Wunsch, Erfahrungen auszutauschen, wenn jemand wie ich anfangen möchte, in Python herumzufummeln. Wenn ich jemandem helfe, habe ich das Ergebnis erreicht.

Fangen wir an!

Ich habe meinen Code in der PyBarm-IDE von JetBrains geschrieben. Betriebssystem - Windows.

Installieren Sie PySide2:

pip install PySide2 

Wenn Sie den Python-Stammordner haben, gehen Sie zu ihm und dann zum Ordner "Lib" -> "Site-Pakete" -> "Pyside2". Sie haben ein Designerprogramm - dies ist das QtDesigner-Programm, mit dem Sie Ihre eigene Programmoberfläche erstellen können. Es ist erwähnenswert, dass Ihre Datei beim Erstellen im Verzeichnis Ihres Projekts das .ui- Format hat, das Python nicht versteht. Daher müssen wir sie in das .py- Format konvertieren. Dies ist jedoch später der Fall .

Erstellen Sie zunächst Ihr Formular.



Wir gestalten unser Design und rufen die Schaltflächen rechts im Unterabschnitt „Objektinspektor“ auf. Es ist erwähnenswert, dass QtDesigner ein kaskadierendes Stylesheet unterstützt. Wenn dies einfacher ist, können Sie durch Suchen des Parameters "styleSheet" in den Eigenschaften Ihr eigenes Design basierend auf CSS-Kenntnissen erstellen.



Als nächstes müssen wir unsere .ui-Datei in ein Format konvertieren, damit Python es versteht. Gehen Sie zur Befehlszeile und schreiben Sie

 pyside2-uic "you_file.ui" -o "your_file.py" 

Was macht der Befehl pyside2-uic? Es konvertiert Ihre .ui- Datei in eine Python- .py- Datei und erstellt daraus eine Python-Klasse. Vielleicht werden sachkundige Leute sagen, dass eine UI-Datei ohne Konvertierung in ein Projekt verbunden werden kann, aber ich werde ordentlich sein und es besser machen, wie es in den Pyside2-Handbüchern geschrieben steht.

Als nächstes gehen Sie zum Code.

Öffnen Sie PyCharm, unser Projektverzeichnis, und erstellen Sie eine Datei mit dem Namen calc_ui.py oder Something_ui.py, je nachdem, welches Programm Sie ausführen. Das Präfix _ui am Ende der Datei hilft uns, nicht in den Dateien verloren zu gehen. Im Allgemeinen sollte es so aussehen:



Beginnen wir mit der Bearbeitung der Datei, die wir von .ui in .py konvertiert haben .

Unten suchen wir nach diesem Code, kopieren ihn und löschen ihn aus dieser Datei.

 if __name__ == '__main__': import sys app = QtWidgets.QApplication(sys.argv) Form = QtGui.QWidget() ui = Ui_Form() ui.setupUi(Form) Form.show() sys.exit(app.exec_()) 

Wir erstellen unsere Hauptdatei, in die die Programmlogik geschrieben wird. Ich nannte es nicht überraschend "calc.py" (oben auf dem Bildschirm des Verzeichnisses ist es sichtbar).

Fügen Sie dort unseren kopierten Code ein und beginnen Sie mit der Bearbeitung.

import sys werden wir am anfang werfen, da es eine regel guter form ist.

Wir importieren einige notwendige Module, um mit unserem Formular zu arbeiten, und aus unserer Datei "calc_ui.py" importieren wir die Hauptklasse Ui_MainWindow .

Bearbeiten Sie als Nächstes, wenn __name__ . Wir löschen alles, was nicht benötigt wird. Sie sollten dies haben:

 if __name__ == '__main__': #   QApplication app = QtWidgets.QApplication(sys.argv) #    ,     calc = Calculator() #  sys.exit(app.exec_()) 

Ich habe den Code hoffentlich klar kommentiert. Fahren wir mit dem Erstellen der Calculator- Klasse fort.

 class Calculator(QtWidgets.QMainWindow, Ui_MainWindow): #   def __init__(self): super().__init__() #    Ui ( ) self.setupUi(self) #    self.show() 

Außerdem ist es unsere Aufgabe sicherzustellen, dass etwas passiert, wenn wir die Tasten "1", "2", "3" usw. drücken.

An derselben Stelle deklarieren wir im Klassenkonstruktor die Schaltflächenverbindung zu einer beliebigen Funktion:

  # pressed self.pushButton.clicked.connect(self.digit_pressed) # 1 self.pushButton_2.clicked.connect(self.digit_pressed) # 2 self.pushButton_3.clicked.connect(self.digit_pressed) # 3 self.pushButton_4.clicked.connect(self.digit_pressed) # 4 self.pushButton_5.clicked.connect(self.digit_pressed) # 5 self.pushButton_6.clicked.connect(self.digit_pressed) # 6 self.pushButton_7.clicked.connect(self.digit_pressed) # 7 self.pushButton_8.clicked.connect(self.digit_pressed) # 8 self.pushButton_9.clicked.connect(self.digit_pressed) # 9 self.pushButton_10.clicked.connect(self.digit_pressed) # 0 self.pushButton_add.clicked.connect(self.pressed_equal) # + self.pushButton_ded.clicked.connect(self.pressed_equal) # - self.pushButton_div.clicked.connect(self.pressed_equal) # / self.pushButton_mul.clicked.connect(self.pressed_equal) # * self.pushButton_exp.clicked.connect(self.pressed_equal) # ** self.pushButton_log.clicked.connect(self.pressed_equal) # log self.pushButton_procent.clicked.connect(self.pressed_equal) # % self.pushButton_ENTER.clicked.connect(self.function_result) # = self.pushButton_C.clicked.connect(self.function_clear) # C self.pushButton_point.clicked.connect(self.make_fractional) # . self.pushButton_delete.clicked.connect(self.function_delete) # < self.pushButton_open_skob.clicked.connect(self.create_big_example) # ( 

Die Funktion self.digit_pressed ist bereits im Code auf den Schaltflächen angegeben. Schauen wir uns das an. Was macht es, wenn der Benutzer mit Zahlen auf die Schaltfläche klickt:

  # lineEdit -  ,         # text() -  ,      # setText() -          # sender() - ,     (   ,    ) def digit_pressed(self): button = self.sender() if self.lineEdit.text() == '0': #        "0",     ,     self.lineEdit.setText(button.text()) else: if self.result == self.lineEdit.text(): self.lineEdit.setText(button.text()) else: self.lineEdit.setText(self.lineEdit.text() + button.text()) self.result = 0 

Kommentare zum Code sind ebenfalls vorhanden.

Stellen Sie sich nun eine Funktion vor, die auf die Druckvorgänge "+" , "-" usw. reagiert.

  clear() -  ,       def pressed_equal(self): button = self.sender() self.first_value = float(self.lineEdit.text()) self.lineEdit.clear() self.label.setText(str(self.first_value) + button.text()) self.equal = button.text() 

Wir schreiben den ersten Wert in die Variable self.first_value und löschen unser Feld, um den Wert der Operation einzugeben, und geben dann zusammen mit der Nummer und der Operation an lineEdit (unser Haupteingabe- und Ergebnisfeld) aus.

Warum schweben ? Ich kann antworten, damit ich mich dazu entscheide, alles float zu machen , und wenn das Ergebnis bei der Ausgabe des Ergebnisblocks am Ende ".0" hat, diesen Teil löschen, so dass die Zahl eine ganze Zahl ist. Ich habe mir keinen besseren vorgestellt.

Wir haben jetzt Funktionen zum Drücken von Zahlen und zum Drücken von Operationen. Wie geht es weiter? Als nächstes müssen wir das Ergebnis anzeigen, dies ist die Schaltfläche = (ENTER) .

  def function_result(self): if self.equal == '+': self.function_addition() elif self.equal == '-': self.function_subtraction() elif self.equal == "/": self.function_divison() elif self.equal == '*': self.function_multiply() elif self.equal == "^": self.exponentiation() elif self.equal == "%": self.function_percent() elif self.equal == "log": self.function_log() 

Ich möchte Sie daran erinnern, dass die Variable self.first_value jetzt genau die erste Variable ist, die wir eingeben, und self.equal die Operation enthält, die wir gedrückt haben. Nachdem wir die zweite Zahl eingegeben und = gedrückt haben, versuchen wir herauszufinden, was die Operation ist, und bestimmen dann die zweite Variable.

Wir gehen weiter zu den Funktionen der Operationen. Ich habe es so verstanden:

  def function_addition(self): self.determinate_second_value() self.result = float(self.first_value + self.second_value) self.form_result() def function_subtraction(self): self.determinate_second_value() self.result = float(self.first_value - self.second_value) self.form_result() def function_divison(self): self.determinate_second_value() self.result = float(self.first_value / self.second_value) self.form_result() def function_multiply(self): self.determinate_second_value() self.result = float(self.first_value * self.second_value) self.form_result() def function_exponentiation(self): self.determinate_second_value() self.result = float(self.first_value ** self.second_value) self.form_result() def function_percent(self): self.determinate_second_value() self.result = float(self.first_value * (self.second_value / 100)) self.form_result() def function_log(self): self.determinate_second_value() self.result = float(math.log(self.first_value, self.second_value)) self.form_result() 

Die Funktion self.determinate_second_value () bestimmt den zweiten Wert der von uns eingegebenen Variablen. Es ist nicht wenig logisch und krumm, aber so wie es ist, werde ich versuchen, alle Fehler später in den Kommentaren zu berücksichtigen, wenn kluge Leute sagen, wie es geht.

Eine kleine Erfrischung.

• self.first_value - hat den Wert der ersten eingegebenen Zahl
• self.equal - hat str die Variable der Operation, die wir gedrückt haben
• self.second_value - hat den Wert der zweiten Variablen

Als nächstes rufen wir in jeder der Operationsfunktionen self.form_result () auf , was seltsamerweise unser Ergebnis bildet. Wir behalten das Ergebnis in der Variablen self.result .

  def form_result(self): self.result = str(self.result) if self.result[-2:] == '.0': self.result = self.result[:-2] self.lineEdit.setText(str(self.result)) self.label.clear() 

Ich werde für Selbst erklären. Ergebnis [-2:] . [-2:] bedeutet, dass wir die letzten 2 Zeichen der Zeichenfolge mit ".0" vergleichen.

Herzlichen Glückwunsch, unser Ergebnis wird im Hauptblock "lineEdit" angezeigt.

Ich werde hier auch einen Code anhängen, der ein Zeichen aus einer Zeichenfolge oder der ganzen Zahl entfernt oder "." (Punkt), um eine Bruchzahl zu erstellen:

  def make_fractional(self): value = self.lineEdit.text() if '.' not in value: self.lineEdit.setText(value + '.') def function_delete(self): value = self.lineEdit.text() self.lineEdit.setText(value[:-1]) def function_clear(self): self.lineEdit.setText('0') 

Der gesamte Code unter dem Spoiler:


Ja, der Rechner berechnet keine großen Funktionen und Ausdrücke, ich arbeite daran!

Vielen Dank für Ihre Aufmerksamkeit. Viel Glück und entwickeln! Das ist cool.

Ich möchte Sie auch zu meinem JuniorProger- Telegrammkanal einladen, wo ich über das Leben eines Junior-Programmierers und seine dornige, aber sehr interessante Art, It-Spezialist zu werden, spreche .