Code bricht ab < Python < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 23:30 Di 23.12.2014 | | Autor: | Marcel |
Hallo,
folgenden Code habe ich einem Buch entnommen, er läuft aber nicht:
| 1: | SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], 1024: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']}
| | 2: |
| | 3: | def approximate_size(size, a_kilobyte_is_1024_bytes=True):
| | 4: | '''Convert a file size to human-readable form.
| | 5: | Keyword arguments:
| | 6: | size -- file size in bytes
| | 7: | a_kilobyte_is_1024_bytes -- if True (default), use multiples of 1024
| | 8: | if False, use multiples of 1000
| | 9: |
| | 10: |
| | 11: | Returns: string
| | 12: |
| | 13: |
| | 14: | '''
| | 15: | if size < 0:
| | 16: | raise ValueError('number must be non-negative')
| | 17: |
| | 18: | multiple = 1024 if a_kilobyte_is_1024_bytes else 1000
| | 19: | for suffix in SUFFIXES[multiple]:
| | 20: | size /= multiple
| | 21: | if size < multiple:
| | 22: | return '{0:.1f} {1}'.format(size, suffix)
| | 23: | raise ValueError('number too large')
| | 24: |
| | 25: | if __name__ == '__main__':
| | 26: | print(approximate_size(1000000000000, False))
| | 27: | print(approximate_size(1000000000000)) |
Fehlermeldung:
python humansize.py
File "humansize.py", line 27
print(approximate_size(1000000000000))
Hat jemand 'ne Idee? Denn eigentlich wollte ich mich mal ein bisschen in
Python einarbeiten...
Gruß,
Marcel
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 23:43 Di 23.12.2014 | | Autor: | felixf |
Moin Marcel!
> Hallo,
>
> folgenden Code habe ich einem Buch entnommen, er läuft
> aber nicht:
> | 1: | SUFFIXES = {1000: ['KB', 'MB', 'GB', 'TB', 'PB',
| | 2: | > 'EB', 'ZB', 'YB'], 1024: ['KiB', 'MiB', 'GiB', 'TiB',
| | 3: | > 'PiB', 'EiB', 'ZiB', 'YiB']}
| | 4: | >
| | 5: | > def approximate_size(size, a_kilobyte_is_1024_bytes=True):
| | 6: | > '''Convert a file size to human-readable form.
| | 7: | > Keyword arguments:
| | 8: | > size -- file size in bytes
| | 9: | > a_kilobyte_is_1024_bytes -- if True (default), use
| | 10: | > multiples of 1024
| | 11: | > if False, use multiples of
| | 12: | > 1000
| | 13: | >
| | 14: | >
| | 15: | > Returns: string
| | 16: | >
| | 17: | >
| | 18: | > '''
| | 19: | > if size < 0:
| | 20: | > raise ValueError('number must be non-negative')
| | 21: | >
| | 22: | > multiple = 1024 if a_kilobyte_is_1024_bytes else 1000
| | 23: | > for suffix in SUFFIXES[multiple]:
| | 24: | > size /= multiple
| | 25: | > if size < multiple:
| | 26: | > return '{0:.1f} {1}'.format(size, suffix)
| | 27: | > raise ValueError('number too large')
| | 28: | >
| | 29: | > if __name__ == '__main__':
| | 30: | > print(approximate_size(1000000000000, False))
| | 31: | > print(approximate_size(1000000000000)) |
Die Anzahl Leerzeichen vor print weicht in den beiden Zeilen voneinander ab. Das ist in Python ein Syntaxfehler.
> Fehlermeldung:
> python humansize.py
> File "humansize.py", line 27
> print(approximate_size(1000000000000))
Ist das alles, was ausgegeben wurde?
LG Felix
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 23:44 Di 23.12.2014 | | Autor: | felixf |
Moin Marcel
> > if __name__ == '__main__':
> > print(approximate_size(1000000000000, False))
> > print(approximate_size(1000000000000))[/code]
>
> Die Anzahl Leerzeichen vor print weicht in den beiden
> Zeilen voneinander ab. Das ist in Python ein Syntaxfehler.
Es kann auch sein, dass du Leerzeichen und Tabs mischt. Das solltest du in Python auf keinen Fall, das endet oft mit Fehlermeldungen oder mindestens Warnungen.
LG Felix
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 15:51 Mi 24.12.2014 | | Autor: | Marcel |
Hallo Felix,
ja, die Fehlermeldung war alles. Ich teste das mal mit den Leerzeichen und
Tabs. Eigentlich habe ich den Code per C&P erstellt, daher muss ich mal
gucken, was da passiert ist...
Edit: Da ich den Fehler immer noch nicht finde, hänge ich einfach mal die
Textdatei an:
![[a]](/images/paperclip.gif "Dateianhänge") humansize.py
Gruß,
Marcel
Dateianhänge:
Anhang Nr. 1 (Typ: py) [nicht öffentlich]
|
|
|
| |
|
Hallo!
Du hast da eindeutig ein Problem. Schau mal:
| 1: |
| | 2: | ....if size < 0:
| | 3: | ........raise ValueError('number must be non-negative')
| | 4: |
| | 5: | ....multiple = 1024 if a_kilobyte_is_1024_bytes else 1000
| | 6: | ....for suffix in SUFFIXES[multiple]:
| | 7: | ........size /= multiple
| | 8: | ........if size < multiple:
| | 9: | ............return '{0:.1f} {1}'.format(size, suffix)
| | 10: | ........raise ValueError('number too large')
| | 11: |
| | 12: | if __name__ == '__main__':
| | 13: | ....print(approximate_size(1000000000000, False))
| | 14: | > > print(approximate_size(1000000000000)) |
Ich habe die Leerzeichen durch Punkte, und die tabs durch ">" dargestellt.
Python ist es recht egal, wenn du bis Zeile 12 in meinem Code Leerzeichen nimmst, und danach Tabs. Du darfst sie nur nicht mixen.
Hier taucht das Problem auf, daß viele Texteditoren gerne beim Drücken von Tab einfach eine bestimmte Anzahl Leerzeichen einfügen, meist 4 oder 8. Andere wiederum fügen tatsächlich ein Tabulator-zeichen ein.
Aus meiner Sicht ist nur das letzte das wirklich ware, weil man dann durch Backspace eine Einrückung vollständig entfernen kann, während man sonst vier mal Backspace drücken muss. (es gibt zwar Editoren, die meinen, das zu können, aber es kommt immer wieder zu Problemen.)
Ungemütlich wird es dann, wenn man ein und den selben Code mit unterschiedlichen Editoren bearbeitet, die sich alle anders verhalten.
Du kannst mal einen Editor wie Notepad++ benutzen, der auch unsichtbare Zeichen anzeigen kann. Dann wird dir sowas schnell auffallen.
Es gibt nun tatsächlich noch ein problem: Wenn nicht schon beim ersten Durchlauf der FOR-Schleife die IF-Bedingung erfüllt ist, rennt der Code danach sofort in das raise VaueError. Du mußt diese Zeile einmal weniger einrücken, damit sie nicht innerhalb der FOR-Schleife ausgeführt wird. Wenn ich das korrigiere, bekomme ich als Ausgabe:
1.0 TB
931.0 GiB
Und jetzt Knecht Ruprecht: 1TByte funktioniert ja. Und wenn du mal 900 Byte versuchst?
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 22:22 Mi 24.12.2014 | | Autor: | Marcel |
Hallo Event_Horizon,
> Hallo!
>
> Du hast da eindeutig ein Problem. Schau mal:
>
> | 1: |
| | 2: | > ....if size < 0:
| | 3: | > ........raise ValueError('number must be non-negative')
| | 4: | >
| | 5: | > ....multiple = 1024 if a_kilobyte_is_1024_bytes else 1000
| | 6: | > ....for suffix in SUFFIXES[multiple]:
| | 7: | > ........size /= multiple
| | 8: | > ........if size < multiple:
| | 9: | > ............return '{0:.1f} {1}'.format(size, suffix)
| | 10: | > ........raise ValueError('number too large')
| | 11: | >
| | 12: | > if __name__ == '__main__':
| | 13: | > ....print(approximate_size(1000000000000, False))
| | 14: | > > > print(approximate_size(1000000000000)) |
>
> Ich habe die Leerzeichen durch Punkte, und die tabs durch
> ">" dargestellt.
>
> Python ist es recht egal, wenn du bis Zeile 12 in meinem
> Code Leerzeichen nimmst, und danach Tabs. Du darfst sie
> nur nicht mixen.
>
> Hier taucht das Problem auf, daß viele Texteditoren gerne
> beim Drücken von Tab einfach eine bestimmte Anzahl
> Leerzeichen einfügen, meist 4 oder 8. Andere wiederum
> fügen tatsächlich ein Tabulator-zeichen ein.
> Aus meiner Sicht ist nur das letzte das wirklich ware, weil
> man dann durch Backspace eine Einrückung vollständig
> entfernen kann, während man sonst vier mal Backspace
> drücken muss. (es gibt zwar Editoren, die meinen, das zu
> können, aber es kommt immer wieder zu Problemen.)
> Ungemütlich wird es dann, wenn man ein und den selben
> Code mit unterschiedlichen Editoren bearbeitet, die sich
> alle anders verhalten.
ich habe, da ich gerade nichts anderes benutzen wollte, einfach das
TexnicCenter benutzt. Ich schau' mich mal nach einem anderen Editor
um.
> Du kannst mal einen Editor wie Notepad++ benutzen, der auch
> unsichtbare Zeichen anzeigen kann. Dann wird dir sowas
> schnell auffallen.
Danke, werde ich mal testen.
> Es gibt nun tatsächlich noch ein problem: Wenn nicht schon
> beim ersten Durchlauf der FOR-Schleife die IF-Bedingung
> erfüllt ist, rennt der Code danach sofort in das raise
> VaueError. Du mußt diese Zeile einmal weniger einrücken,
Mache ich.
> damit sie nicht innerhalb der FOR-Schleife ausgeführt
> wird. Wenn ich das korrigiere, bekomme ich als Ausgabe:
>
> 1.0 TB
> 931.0 GiB
>
>
> Und jetzt Knecht Ruprecht: 1TByte funktioniert ja. Und wenn
> du mal 900 Byte versuchst?
Ich teste erstmal, ob ich das Programm überhaupt zum Laufen bringe. 
P.S. Du kennst das Buch, oder war die Testeingabe zufällig genauso wie
dort?
Edit: Jetzt bekomme ich zwar eine Ausgabe, aber immer
1.0 TB
931.0 GiB
Eigentlich sollte das Programm ja den String einlesen und entsprechend
umrechnen. Ist da noch was falsch?
Ich muss auch ehrlich sagen: Normalerweise kenne ich mich in der
Programmierung etwas aus (Matlab, Octave, R, ..., in C etwas), aber
hier weiß ich zwar immer, was gemacht werden soll, aber die Syntax
ist mir nicht immer klar. Alleinde schon dieses "=TRUE" finde ich an
den entsprechenden Stellen komisch.
Aber die Autoren im Buch meinten, man könne erst mal das Programm
laufen lassen, sie erklären es dann danach. Daher halte ich mich an
diese Strategie, nur sollte das Ding dafür auch mal richtig funktionieren. 
Gruß,
Marcel
|
|
|
| |
|
Hallo!
Dein Code enthält die ganze Zeit die Zeile(n)
print(approximate_size(1000000000000))
sprich, das wird immer nur ~1TB ausgeben, sonst nix. Ich weiß nichts von einem Buch...
Wenn du von einem String sprichst: Den mußt du ja erstmal einlesen, z.B. so:
n=int(raw_input("Bitte Zahl eingeben: "))
print(approximate_size(n))
Das raw_input() liefert dir einen String, welchen du erstmal in eine ganze Zahl umwandeln mußt, daher das int().
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 02:24 Fr 26.12.2014 | | Autor: | Marcel |
Hallo Event_Horizon,
> Hallo!
>
> Dein Code enthält die ganze Zeit die Zeile(n)
>
> print(approximate_size(1000000000000))
>
> sprich, das wird immer nur ~1TB ausgeben, sonst nix. Ich
> weiß nichts von einem Buch...
kein Problem, ich kann's Dir nennen.
> Wenn du von einem String sprichst: Den mußt du ja erstmal
> einlesen, z.B. so:
>
>
> n=int(raw_input("Bitte Zahl eingeben: "))
> print(approximate_size(n))
>
> Das raw_input() liefert dir einen String, welchen du
> erstmal in eine ganze Zahl umwandeln mußt, daher das
> int().
Okay, das kenne ich analog aus Matlab (input-Befehl). Dann nehme ich
mal an, dass die im Buch den Codeteil verloren haben (mir kam das auch
merkwürdig vor, was dort steht - es steht aber nun mal so da).
Bzw. es kann sein, dass da einfach nur diese Umrechnung ausgegeben
werden soll (1TB - 931.3 GiB); und dieses Einlesen des Strings etc. erst
später kommt, wobei sie dann das Programm abändern. Das klingt dann
logisch. (Vielleicht sollte ich jetzt einfach erstmal weiterlesen; aller Anfang
ist halt schwer... .)
Aber dennoch ist das Programm dann komisch geschrieben. Jetzt läuft's
aber wenigstens, daher: Danke.
(Nachträglich frohe Festtage und einen guten Rutsch schonmal!)
Gruß,
Marcel
|
|
|
| |
|
Hallo!
Naja, das kann so sein:
Du hast hier eine Python-Datei mit dieser Funktion approximateSize(), oder wie sie gleich noch hieß.
Du kannst diese Datei mit 'import' in eine andere Python-Datei einbinden (ähnlich #include in C), und die Funktion benutzen.
ABER du kannst die Datei selbst auch ausführen, dafür ist das
if __name__ == '__main__':
gut. Es prüft, ob diese Datei direkt ausgeführt wird, oder eben nicht (d.h. per import von ner anderen Datei eingebunden wurde)
Das mit der Benutzereingabe kann also in ner anderen Datei stehen.
|
|
|
|
