Python bietet mehrere zusätzliche mathematische Operationen.

# Default division
print(18 / 4)

# Floor division
print(18 // 4)

# Remainder of the division
print(18 % 4)

# Raising to the power of 4
print(18 ** 4)

### Warum sind diese Operationen hilfreich?  

Stellen Sie sich vor, Sie haben **$50** und möchten so viele Keks-Packungen wie möglich kaufen, wobei jede Packung **$6** kostet. Um zu bestimmen, wie viele Packungen Sie kaufen können und wie viel Geld übrig bleibt, können Sie diese Operationen verwenden:  

- `50 // 6` ergibt `8`, was bedeutet, dass Sie **8 Packungen** kaufen können.  
- `50 % 6` ergibt `2`, was bedeutet, dass Sie nach dem Kauf **$2 übrig** haben.  

import unittest
import importlib
import io
import re
import sys

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_floor_division_present(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        floor_div_check = re.search(r'234\s*//\s*32', user_code_source)

        _dynamic_test(
            self,
            floor_div_check is not None,
            "The floor division operation `234 // 32` is present.",
            "Expected the floor division operation `234 // 32` to be present."
        )

    def test_modulus_operation_present(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        modulus_check = re.search(r'356\s*%\s*17', user_code_source)

        _dynamic_test(
            self,
            modulus_check is not None,
            "The modulus operation `356 % 17` is present.",
            "Expected the modulus operation `356 % 17` to be present."
        )

    def test_floor_division_output_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")

        _dynamic_test(
            self,
            output[0] == "7",
            "The correct result `7` is printed for floor division.",
            f"Expected `7` to be printed, but got `{output[0]}`."
        )

    def test_modulus_output_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")

        _dynamic_test(
            self,
            output[1] == "16",
            "The correct result `16` is printed for modulus.",
            f"Expected `16` to be printed, but got `{output[1]}`."
        )

if __name__ == '__main__':
    unittest.main()


test_main.py

Python ist eine interpretierte, hochgradig allgemeine Programmiersprache. Im Gegensatz zu HTML, CSS und JavaScript, die hauptsächlich für die Webentwicklung verwendet werden, ist Python vielseitig und kann in verschiedenen Bereichen eingesetzt werden, einschließlich Softwareentwicklung, Datenwissenschaft und Back-End-Entwicklung. In diesem Kurs werden Sie die Kernaspekte von Python erkunden, und am Ende werden Sie Ihre eigenen Funktionen erstellen!

Tauchen Sie in die Grundlagen von Python ein, erkunden Sie Ihren Arbeitsbereich und führen Sie einfache mathematische Operationen durch. Lernen Sie, wie Sie lesbaren Code mit Kommentaren schreiben und sowohl grundlegende als auch fortgeschrittene mathematische Ausdrücke handhaben, während Sie Ihre Ergebnisse anzeigen.

Lernen Sie, wie Sie Daten in Python speichern und verwalten, indem Sie mit Zahlen, Text und Variablen arbeiten. Verstehen Sie, wie Werte zugewiesen werden, Namenskonventionen befolgt werden und verschiedene Datentypen erkundet werden. Sammeln Sie praktische Erfahrungen mit Zeichenkettenoperationen, Indizierung, Slicing und Speicherabruftechniken, um Text in Python effizient zu manipulieren.

Lernen Sie, wie man Vergleichs- und logische Operatoren verwendet, mit bedingten Ausdrücken arbeitet und Mitgliedschafts- und Typvergleiche anwendet. Bauen Sie eine solide Grundlage im Schreiben von Programmen, die dynamisch auf verschiedene Bedingungen mit if/else- und if/elif/else-Strukturen reagieren.

Erweitern Sie Ihr Verständnis von Datentypen, indem Sie lernen, wie Sie mehrere Attribute in einer einzigen Variablen gruppieren können. Erkunden Sie Lists, Tuples und Dictionaries, um strukturierte Daten effizient zu speichern und zu verwalten, zusammen mit wesentlichen Methoden zur Manipulation und Abfrage.

Meistern Sie die Kunst, Schleifen in Python zu schreiben – wesentliche Konstrukte zum Iterieren über Listen, Tupel, Dictionaries und andere Datenstrukturen. Lernen Sie, while- und for-Schleifen effektiv zu nutzen, die range-Funktion zu erkunden und mit verschachtelten Schleifen zu arbeiten, um komplexe Iterationsmuster zu bewältigen.

Erkunden Sie wesentliche eingebaute Funktionen in Python und machen Sie den nächsten Schritt, indem Sie Ihre eigenen erstellen. Lernen Sie, wie man Funktionen definiert, bedingte Logik verwendet, bestehende Funktionen modifiziert und mit lambda-Ausdrücken arbeitet, um effizienten, wiederverwendbaren Code zu schreiben.

Komplexere Mathematik in Python Handhaben

Warum sind diese Operationen hilfreich?

Lösung

Komplexere Mathematik in Python Handhaben

Warum sind diese Operationen hilfreich?

Lösung