Unterschied zwischen print und return

[King Anda]

Hallo Leute,

Sorry, kompletter Neuling.
Die Suche konnte mir leider nicht weiterhelfen, drum nerv ich euch direkt mit einem neuen Thread:

Ich hab ein bisschen herumprobiert und ein Modul geschrieben, das mir nach Eingabe einer Zahl die römische Zahl dazu ausgibt.
Beim Schreiben und Testen hab ich das immer mit der print Funktion gemacht, die hat mir dann auch die römische Zahl schön ausgegeben. z.B MM C XXX II für 2132

Wenn ich das Ganze jetzt in eine Funktion packe und das Ergebnis, das ich vorher mittels print angezeigt habe jetzt als "return" ausgeben lassen will, dann gibt das Programm jede einzelne Stelle der römischen Zahl mit Anführungsstrichen und Beistrich aus. ("MM", " ", "C", " ", "XXX", " ", "II")
Also auch leere "" für die im Beispiel fehlenden Stellen D oder L oder V...

Das sieht ein bisschen ungünstig aus.
Deswegen wollte ich fragen, warum hier so ein Unterscheid zwischen print und return ist.

Oder vielleicht hab ich auch einen kompletten Denkfehler und muss den kompletten Aufbau nochmal überdenken.
Bin um jeden Tipp froh, danke schon mal im Voraus

Beste Grüße
Anda

[sparrow]

Du musst schon deinen Code zeigen, sonst können wir nicht sagen, was das Problem ist.
Und zwar direkt als Text in einem Beitrag zwischen Code-Tags. Die Code-Tags erscheinen automatisch, wenn du den </> Button im vollständigen Editor drückst.

Ansonsten kann man dazu nicht viel sagen, außer:
"print" gibt es etwas auf dem Bildschirm aus
"return" gibt etwas aus einer Funktion zurück.

Beides hat miteinander nichts gemein.

[__blackjack__]

@King Anda: Du kannst nichts mit ``return`` ausgeben lassen. Die ``return``-Anweisung beendet die Funktion und gibt einen Wert an den Aufrufer der Funktion zurück. Dabei findet keine Ausgabe statt wie bei `print()`. Beim Aufrufer könnte man dann `print()` aufrufen, mit dem zurückgegebenen Wert als Argument. Es macht aber keinen Unterschied ob man `print()` in der Funktion aufruft, mit dem Wert, oder beim Aufrufer `print()` benutzt um den selben Wert auszugeben. Die Ausgabe ist in beiden Fällen gleich, wenn der Aufruf der Funktion äquivalent war.

Du hast da offenbar ein Tupel mit den Bestandteilen der Ausgabe als Zeichenketten. Hier sieht man, dass es keinen Unterschied macht wo die Ausgabe stattfindet:

Code: Alles auswählen

In [55]: def f(): 
    ...:     result = ("MM", " ", "C", " ", "XXX", " ", "II") 
    ...:     print(result) 
    ...:                                                                        

In [56]: def g(): 
    ...:     result = ("MM", " ", "C", " ", "XXX", " ", "II") 
    ...:     return result 
    ...:                                                                        

In [57]: f()                                                                    
('MM', ' ', 'C', ' ', 'XXX', ' ', 'II')

In [58]: print(g())                                                             
('MM', ' ', 'C', ' ', 'XXX', ' ', 'II')

[King Anda]

Ok, danke schon mal.

Hier der Code.
Ich hab die Funktion und den return "auskommentiert."
Und wenn man die def "aktiviert" fehlt natürlich die Einrückung.

Anda

Code: Alles auswählen

latin_number = int(input("Bitte Zahl eingeben: "))

# def transform(latin_number):
if latin_number >= 1000:
    m = int(latin_number / 1000)
elif latin_number <= 1000:
    m = 0
if (latin_number - m * 1000) >= 500:
    d = int((latin_number - m * 1000) / 500)
elif (latin_number - m * 1000) <= 500:
    d = 0
if (latin_number - m * 1000 - d * 500) >= 100:
    c = int((latin_number - m * 1000 - d * 500) / 100)
elif (latin_number - m * 1000 - d * 500) <= 100:
    c = 0
if (latin_number - m * 1000 - d * 500 - c * 100) >= 50:
    l = int((latin_number - m * 1000 - d * 500 - c * 100) / 50)
elif (latin_number - m * 1000 - d * 500 - c * 100) <= 50:
    l = 0
if (latin_number - m * 1000 - d * 500 - c * 100 - l * 50) >= 10:
    x = int((latin_number - m * 1000 - d * 500 - c * 100 - l * 50) / 10)
elif (latin_number - m * 1000 - d * 500 - c * 100 - l * 50) <= 10:
    x = 0
if (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10) >= 5:
    v = int((latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10) / 5)
elif (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10) <= 5:
    v = 0
if (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10 - v * 5) >= 1:
    i = int((latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10 - v * 5) / 1)
elif (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10 - v * 5) <= 1:
    i = 0
    # return m * 'M', d * 'D', c * "C", l * "L", x * "X", v * "V", i * "I"


print(m * "M", d * "D", c * "C", l * "L", x * "X", v * "V", i * "I")

[Sirius3]

Wenn die Bedingung in elif quasi das Gegenteil der if-Bedingung ist, benutzt man else. Statt das Ergebnis einer Division wieder in eine Ganzzahl umzuwandeln, benutzt man Ganzzahldivision:

Code: Alles auswählen

if latin_number >= 1000:
    m = latin_number // 1000
else:
    m = 0
if (latin_number - m * 1000) >= 500:
    d = (latin_number - m * 1000) // 500
else:
    d = 0
if (latin_number - m * 1000 - d * 500) >= 100:
    c = (latin_number - m * 1000 - d * 500) // 100
else:
    c = 0
if (latin_number - m * 1000 - d * 500 - c * 100) >= 50:
    l = (latin_number - m * 1000 - d * 500 - c * 100) // 50
else:
    l = 0
if (latin_number - m * 1000 - d * 500 - c * 100 - l * 50) >= 10:
    x = (latin_number - m * 1000 - d * 500 - c * 100 - l * 50) // 10
else:
    x = 0
if (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10) >= 5:
    v = (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10) // 5
else:
    v = 0
if (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10 - v * 5) >= 1:
    i = (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10 - v * 5) // 1
else:
    i = 0
print(m * "M", d * "D", c * "C", l * "L", x * "X", v * "V", i * "I")

Nun ist aber wenn eine kleinere Zahl durch eine größere Zahl ganzzahldividiert wird, das Ergebnis 0, so dass alle if-Abfragen überflüssig sind:

Code: Alles auswählen

m = latin_number // 1000
d = (latin_number - m * 1000) // 500
c = (latin_number - m * 1000 - d * 500) // 100
l = (latin_number - m * 1000 - d * 500 - c * 100) // 50
x = (latin_number - m * 1000 - d * 500 - c * 100 - l * 50) // 10
v = (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10) // 5
i = (latin_number - m * 1000 - d * 500 - c * 100 - l * 50 - x * 10 - v * 5) // 1
print(m * "M", d * "D", c * "C", l * "L", x * "X", v * "V", i * "I")

Statt mehrfach so langen Berechnungen anzustellen, speichere doch das Ergebnis in einer Variable:

Code: Alles auswählen

m = latin_number // 1000
latin_number -= m * 1000
d = latin_number // 500
latin_number -= d * 500
c = latin_number // 100
latin_number -= c * 100
l = latin_number // 50
latin_number -= l * 50
x = latin_number // 10
latin_number -= x * 10
v = latin_number // 5
latin_number -= v * 5
i = latin_number
print(m * "M", d * "D", c * "C", l * "L", x * "X", v * "V", i * "I")

Das ist aber nichts anders als Division mit Rest, dafür gibt es divmod:

Code: Alles auswählen

m, latin_number = divmod(latin_number, 1000)
d, latin_number = divmod(latin_number, 500)
c, latin_number = divmod(latin_number, 100)
l, latin_number = divmod(latin_number, 50)
x, latin_number = divmod(latin_number, 10)
v, i = divmod(latin_number, 5)
print(m * "M", d * "D", c * "C", l * "L", x * "X", v * "V", i * "I")

Wenn man so einen regelmäßigen Code hat, dann möchte man das mit einer Schleife ausdrücken:

Code: Alles auswählen

result = []
for character, value in [("M", 1000), ("D", 500), ("C", 100), ("L", 50), ("X", 10), ("V", 5), ("I", 1)]:
    v, latin_number = divmod(latin_number, value)
    result.append(v * character)
print(*result)

Zum Schluß geht es darum, das Ergebnis in einen String umzuwandeln, und dafür gibt es str.join:

Code: Alles auswählen

def transform(latin_number):
    result = []
    for character, value in [("M", 1000), ("D", 500), ("C", 100), ("L", 50), ("X", 10), ("V", 5), ("I", 1)]:
        v, latin_number = divmod(latin_number, value)
        result.append(v * character)
    return "".join(result)

Am Algorithmus fehlt der Sonderfall: CCCC -> CD, LXXXX -> XC, etc.

[King Anda]

Wow, danke.
Da hab ich noch einiges zu tun.

Vielen Dank für die Ausführliche Erklärung.
Es war mir eh bewusst, dass ich hier wahrscheinlich ein paar mal mit der Kirche ums Dorf fahre, aber wie gesagt ich hab meine ersten Lernerfahrungen versucht kreativ umzusetzen

SG

[Xtremdiver]

Am Algorithmus fehlt der Sonderfall: CCCC -> CD, LXXXX -> XC, etc.

Du warst doch schon am Ziel, den einen Schritt hättest du ja auch noch machen können ;o)

Code: Alles auswählen

def transform(latin_number):
    result = []
    for character, value in [("M", 1000), ("CM", 900), ("D", 500), ("CD", 400), ("C", 100), ("XC", 90), ("L", 50), ("XL", 40), ("X", 10), ("IX", 9), ("V", 5), ("IV", 4), ("I", 1)]:
        v, latin_number = divmod(latin_number, value)
        result.append(v * character)
    return "".join(result)

Vielen Dank für das schöne Rätsel