Stefan Ram wrote:
> Patrick Rudin <taxi_bs(a)gmx.ch> schrieb oder zitierte:
>> Bin mal auf die Python-Eigenheiten gespannt, wenn ich mich endlich an
>> Klassen wage...
>
> Hier das Hallo-Welt-Programm für Klassen in Python:
>
> Quelltext
>
> class HalloWelt:
> print( "Hallo Welt!" )
Danke für die Bestätigung, dass Hallo Welt-Programme für das Aufzeigen
von Unterschieden zwischen verschiedenen Programmiersprachen nutzlos sind.
Eigentlich …
[View More]dachte ich eher daran, ob eine Instanz weiss, die wievielte
Instanz des Objekts sie aktuell ist und ob sie direkt auf Methoden der
vorherigen und nächsten (falls vorhanden) Instanz zugreifen kann.
Gruss
Patrick
[View Less]
On 2024-08-11 13:48, Stefan Ram <ram(a)zedat.fu-berlin.de> wrote:
> "Peter J. Holzer" <hjp-usenet4(a)hjp.at> schrieb oder zitierte:
>>On 2024-08-11 10:46, Stefan Ram <ram(a)zedat.fu-berlin.de> wrote:
>>>"Zeiger" gibt es in C.
>>"Zeiger" ist ein programiersprachenübergreifendes Konzept.
>
> Die Vorstellung einer programiersprachenübergreifenden Terminologie
> führt immer wieder zu Begriffsverwirrungen. Letztendlich definiert
> jede …
[View More]Programmiersprache ihre eigenen Begriffe.
Zweifellos, aber das ändert nichts daran, dass es die Konzepte
programiersprachenübergreifend gibt. Es bringt nichts, so zu tun, als ob
ein gebundener Name in Python etwas ganz anderes wäre als ein Pointer in
Pascal. Beides sind Implementationen des gleichen Konzepts. Oder zu
behaupten, dass entweder C oder Pascal einen Pointer falsch
implementieren, weil beide Sprachen das gleiche Wort für etwas
verwenden, das sich in (wichtigen!) Details unterscheidet.
Man braucht eine Sprache, um über Programmiersprachen sprechen zu
können. Natürliche Sprachen (auch Fachsprachen) haben nicht für jedes
Konzept ein anderes Wort. Man muss im Kontext erkennen, ob mit "Pointer"
gerade das Konzept des Pointers im Allgemeinen, ein Pointer in C oder
einer in Pascal gemeint ist. Oder vielleicht etwas ganz anderes wie ein
Mauszeiger. Wenn das nicht möglich ist, muss man das halt ergänzen oder
eine lokale Terminologie definieren.
>>Zeiger mögen in verschiedenen Programmiersprachen anders genannt
>>werden und leicht unterschiedliche Eigenschaften haben (in C kann man
>>z.B. damit rechnen, in den meisten anderen Sprachen nicht), aber das
>>Grundkonzept gibt es fast überall.
>
> Zeiger gehören zum Laufzeitmodell, während Namen zum Quelltextmodell
> gehören.
>
> Das heißt: Ein Zeiger ist ein Wert, der relevant ist, wenn man
> beschreibt, was bei der Ausführung eines Programms passiert.
> Er steht nicht im Quelltext. Ein Name ist umgekehrt etwas das
> im Quelltext steht.
Das ist eben bei Python nicht so. Der "Name" existiert sehr wohl zur
Laufzeit, und die Bezeichnung "Name" wird auch nicht nur für Identifier
verwendet, sondern für alles, was "gebunden" werden kann.
> Mit dem Begriff "Bindung" drückt man aus,
> daß eine Quelltextentität (Name) mit einer Laufzeit (Objekt)
> verbunden ist.
Die Language Reference ist meiner Meinung nach sehr klar darin, dass
"binding operations" und "unbinding operations" Laufzeitoperationen
sind, die auf Entitäten operieren, die zur Laufzeit existieren.
>>>In Python sind Namen an Objekte /gebunden/.
>>Das ist der übliche Jargon in Python,
>
> Das sind die /korrekten Fachbegriffe/ aus "The Python Language
> Reference" von Guido van Rossum und kein "Jargon"!
Korrekte Fachbegriffe sind immer Jargon (laut Duden "Sondersprache
bestimmter durch Beruf, Stand, Milieu geprägter Kreise mit speziellem
[umgangssprachlichem] Wortschatz").
>>ich halte ihn aber aus mehreren Gründen für irreführend:
>>1. "Binden" ist ein Verb. Das beschreibt also eine Operation, nämlich
>> genau die, die anderswo in der Dokumentation als "assignmen"
>> (Zuweisung) bezeichnet wird.
>
> Beim /Binden/ wird, wie ich oben ausgeführt hatte, eine
> Quelltextentität (der Name) mit einer Laufzeitentität (dem
> Objekt) verbunden.
>
> Bei einer /Zuweisung/ (Begriff aus anderen Programmiersprachen)
> wird ein Wert (eine Laufzeitentität) in einen Wertspeicher
> (ebenfalls eine Laufzeitentität!) geschrieben.
Ich halte diese Unterscheidung für falsch (d.h. sie geht weder aus der
Language Reference hervor noch entspricht sie dem Sprachgebrauch). Aus
der Language Reference kann man herauslesen, dass eine Zuweisung eine
bestimmte Art der Bindung ist, aber das bezieht sich auf die
syntaktische Form (assignment expressions), nicht die Semantik. Und im
Sprachgebrauch wird der Begriff assignment jedenfalls nicht nur für
assignment expressions verwendet: Ein Satz wie "a function definition is
a form of assignment" ist unauffällig.
>>(Zuweisung) bezeichnet wird. "Gebunden" ("bound") sagt also
>>eigentlich nur aus, dass dem Namen bereits irgendetwas zugewiesen
>>wurde. Es sagt wenig darüber aus, was das für Folgen hat und was man
>>dann damit machen kann.
>
> Das wird in "The Python Language Reference" ausführlich beschrieben.
>
>>2. "Gebunden" hat keine klare Richtung. Wenn A an B gebunden ist, hängt
>> dann A an B oder B an A oder hängen sie aneinander?
>
> In Python kann man die Richtung in einem gegebenen Kontext immer
> daran erkennen, daß auf einer Seite ein Name (eine Quelltextentität)
> und auf der anderen Seite ein Objekt (eine Laufzeitentität) steht.
Dir fällt jetzt aber nicht auf, dass auch Dein Satz keine Aussage über
die Richtung trifft?
>>> def f():
>>> Hans = 5
>>> def g():
>>> Hans = 6
>>Das sind andere Namen. Der Scope gehört zum Namen, auch wenn er nicht
>>explizit geschrieben wird.
>
> "Hans" ist ein anderer Name als "Hans"? Der Gültigkeitsbereich
> gehört zum Namen? Das könnte die Kommunikation mit anderen
> erschweren, wenn man solche Begriffe verwendet!
Das Konzept des Namespace ist seit Jahrzehnten erfunden und
Informatikern wohlvertraut. Ein Name existiert innerhalb seines
Namespaces. Der Identifier ist in beiden Fällen gleich, aber es sind
unterschiedliche Namen.
Du begehst hier genau den Fehler, den Du mir oben vorgeworfen hast. Du
verwendest nicht die Fachsprache, sondern allgemeines Deutsch.
Aber ja, genau das ist der Grund, warum ich die Bezeichnung "Name" hier
für unpraktisch halte. Sie verleitet zu falschen Schlüssen, weil jeder
glaubt, zu wissen, was ein "Name" ist.
> Du kannst natürlich Deine ganz eigene Terminologie aufstellen,
Vor jemandem, der im Usenet berüchtigt für seine unverständliche
Privatterminologie ist, ist dieser Vorwurf einigermaßen lustig.
hp
[View Less]
On 2024-08-11 10:46, Stefan Ram <ram(a)zedat.fu-berlin.de> wrote:
> "Peter J. Holzer" <hjp-usenet4(a)hjp.at> schrieb oder zitierte:
>>Es gibt natürlich auch Unterschiede, z.B. kann in Python ein Name immer
>>nur auf genau ein Objekt zeigen
>
> "Zeiger" gibt es in C.
"Zeiger" ist ein programiersprachenübergreifendes Konzept. Zeiger mögen
in verschiedenen Programmiersprachen anders genannt werden und leicht
unterschiedliche Eigenschaften haben (in C kann man z.…
[View More]B. damit rechnen,
in den meisten anderen Sprachen nicht), aber das Grundkonzept gibt es
fast überall.
> In Python sind Namen an Objekte /gebunden/.
Das ist der übliche Jargon in Python, ich halte ihn aber aus mehreren
Gründen für irreführend:
1. "Binden" ist ein Verb. Das beschreibt also eine Operation, nämlich
genau die, die anderswo in der Dokumentation als "assignmen"
(Zuweisung) bezeichnet wird. "Gebunden" ("bound") sagt also
eigentlich nur aus, dass dem Namen bereits irgendetwas zugewiesen
wurde. Es sagt wenig darüber aus, was das für Folgen hat und was man
dann damit machen kann.
2. "Gebunden" hat keine klare Richtung. Wenn A an B gebunden ist, hängt
dann A an B oder B an A oder hängen sie aneinander?
Die Verbindung zwischen einem Namen und einem Objekt in Python
hingegen hat eine eindeutige Richtung: Man kommt vom Namen zum
Objekt, aber nicht vom Objekt zum Namen. Der Name "zeigt" also auf
das Objekt, das Objekt "zeigt" nirgendwohin. Graphisch wird man das
üblicherweise durch einen Pfeil vom Namen zum Objekt darstellen.
Ich halte daher die Formulierung "der Name zeigt auf das Objekt" nicht
für richtig, sondern sogar für besser als "der Name ist an das Objekt
gebunden", insbesondere dann, wenn man Leuten etwas erklären will, die
nicht schon seit Jahren auf der Python-Mailinglist subscribiert sind.
> Ein Name kann an verschiedene Objekte gebunden sein, aber mit
> Gültigkeitsbereich und Existenzdauer zusammen wird er dann eindeutig.
>
> Gültigkeitsbereich (statisch):
>
> def f():
> Hans = 5
>
> def g():
> Hans = 6
Das sind andere Namen. Der Scope gehört zum Namen, auch wenn er nicht
explizit geschrieben wird.
(Das ist ein weiterer Grund, warum ich mit der Bezeichnung "Name"
unglücklich bin. Damit verbindet man unwillkürlich die Zeichenfolge. Es
geht aber um die Datenstruktur, die dahintersteckt.)
hp
[View Less]
Stefan Ram wrote:
> Du meinst vielleicht, daß es keine Aliasse für /Stellen/ von
> Listen gibt. Was also nicht geht ist:
>
> |>>>| a =[ 1, 2, 3 ]
> |>>>| b = alias_for( a[ 1 ])
> |>>>| b = 4
> |>>>| print( a )
> | | [1, 4, 3]
Ja, genau sowas. Für Fälle von unpacking, wo eine wirklich nur zu 99
Prozent lesend verwendet?
> . In Python gibt es eine universelle Regel, welche immer für
> "b = 4" gilt und die besagt, …
[View More]daß durch die Ausführung von "b = 4"
> der Name b an das Objekt 4 gebunden wird. Würde man nun solche
> Aliasse erlauben, dann würde es für die Bedeutung von "b = 4"
> eine spezielle Ausnahme für den Fall, daß b ein Alias ist, geben
> müssen, aber in Python sagt man: "Besondere Fälle sind nicht so
> besonders, daß man ihretwegen gegen die Regeln verstoßen muß.".
Dem verlinkten Vortrag meine ich zu entnehmen, dass mein Missverständnis
gerade in Bezug auf Listen nicht so selten ist...
Gruss
Patrick
[View Less]
On 2024-08-07 10:03, Stefan Ram <ram(a)zedat.fu-berlin.de> wrote:
> ram(a)zedat.fu-berlin.de (Stefan Ram) schrieb oder zitierte:
>>Dieses Nichtvorkommen legt es für mich nahe, daß die Frage
>>der Veränderbarkeit des Ziels für die Bedeutung von "+="
>>nur eine begrenzte Bedeutung hat!
>>|An augmented assignment evaluates the target (which, unlike
>>|normal assignment statements, cannot be an unpacking) and the
>>|expression list, performs the binary …
[View More]operation specific to
>>|the type of assignment on the two operands, and assigns the
>>|result to the original target.
>>aus Abschnitt 7.2.1
>
> Ich hatte gestern etwas übersehen! Und zwar (in bezug auf
> Operatoren wie "+="):
>
>|Also, when possible, the actual operation is performed
>|in-place, meaning that rather than creating a new object and
>|assigning that to the target, the old object is modified
>|instead.
> 7.2.1
[...]
>
> (In "7.2.1" besagt "assigns the result to the original target"
> eigentlich, daß "+=" sich hier wie "=" verhält.
Exakt. Der Unterschied liegt in der Implementation der Methode __iadd__,
nicht in der Zuweisung.
hp
[View Less]
Sehr geehrter Herr Schnoor,
hier einige Fragen zu Ihrer Codepage-Methode und dem ominösen Zahlensystem zur Basis 4096.
Frage 1
Warum wählten Sie die Basis b = 4096 für Ihre Codepage-Methode (CPM) zum Nummerieren der UTF8-Zeichen?
Antwort: Da Sie bis jetzt diese Frage nicht beantwortet haben, hier ein Antwortversuch von mir.
Frage 2
Was ist Zweck oder Ziel der CPM? Wozu das Monster-Zahlensystem 4096?
Antwort: Sie wollen mit CPM den Speicherbedarf (gemessen in 8-Bit-Byte) für die dezimalen „…
[View More]Hausnummern“ ord(ch) der UTF8-Zeichen ch reduzieren, und zwar auf knapp die Hälfte, durch Verwendung der 4096-Index-Nummern, in die die dezimalen Hausnummern übersetzt werden. Die sind gewissermaßen getunte Hex-Zahlen (statt der Basis 16 die Superbasis 4096).
Und wozu dieser Aufwand?
Die byte-reduzierten Hausnummern werden anstelle von Klartextnachrichten übers Netz verschickt.
CPM ist im Kern eine Symmetrische Chiffre mit dem System-Ziffernstring als Schlüssel.
Frage 3
(damit man sieht, wo man anfängt, wo’s langgeht, und wo man endet):
Wie groß muß die Basis b>1 eines Zahlensystems sein, wenn man mit höchstens 2 Ziffern dieses Systems genau 256 Zahlen (0..255) notieren können will.
Antwort: b = 16 = Wurzel aus 256, System = Hex-Zahlen
Denn mit 16 verschiedenen Ziffern kann man 16**2 = 256 ein- oder zweiziffrige Hex-Zahlzeichen notieren.
Was einmal geht, geht auch zweimal. Dachten Sie wohl.
Und ich auch.
Darum hier die zu Frage 3 analoge
Frage 4
Welche (minimale) System-Basis b>1 braucht man zum Nummerieren der aktuell 1.114.111 UTF8-Zeichen, wenn man zum Nummerieren höchstens 2-ziffrige Zahlzeichen verwenden will?
Antwort: b = 1056 = gerundete Wurzel aus 1.114.111.
Überraschung Eins:
Die Antwort hat mich überrascht: Optimale Basis = wenig größer als ein Viertel der Superzahl.
==============================
Da Ihre CPM für alle Basiswerte 2 <= b <= 4098 anwendbar ist, habe ich den Rechner zur Basis-Testung angeworfen.
Und die jeweilige Byte-Reduktion ermittelt.
Welchen Ziffernstring habe ich verwendet?
Den einfachsten: Alle UTF8-Zeichen von 0 bis zur jeweiligen Basis b.
ziffern = ''.join([ chr(x) for x in range(0, 4096) ])
Anzahl Ziffern : 4096
Anzahl Bytes : 10112
Dieser Ziffernstring ist optimal, denn der enthält die Zeichen mit den wenigsten Byte. Es gibt keinen Ziffernstring mit weniger Byte.
Die Basis läßt sich beliebige verkleinern durch Slicing, z.B.
basis = 128
ziffern = ziffern[:basis]
==========================
Überraschung Zwei:
Der Test lieferte eine merkwürdiges Ergebnis:
Die größte Byte-Reduktion über alle Codepoints 1 bis 1.114.111 liefert eine dreistellige Basis, b = 128.
Hier das Testergebnis für b = 128:
Basis für CPM : 128
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0] # ANZAHL der UTF8-Zeichen mit 0,1,2,3,4,5 Byte
BytesIndex : [0, 128, 16256, 1095680, 0] # ANZAH der Index-Zahlzeichen mit 0,1,2,3,4 Byte
ZiffernIndex : [0, 128, 16256, 1095680, 0] # ANZAH der Index-Zahlzeichen mit 0,1,2,3,4 Ziffern
Σ Bytes UTF8 : 4382592 # Gesamtzahl der Bytes in allen 1.114.111 UTF8-Zeichen
Σ Bytes Index : 3319680 # Gesamtzahl der Bytes in allen 1.114.111Index-Zahlzeichen
Diff (I - U) : -1062912 # klar
Quote (I : U) : 75.75% # klar
Reduktion : -24.25% # klar
Ergebnis in Worten für b=128:
ZiffernIndex: Es werden nur 1-, 2- oder 3-ziffrige Zahlzeichen verwendet;
BytesIndex: Diese Zeichen haben 1, 2, oder 3 Byte.
Die Anzahl der Zahlzeichen ist gleich der Anzahl der Byte.
Dies ist vollkommen logisch. Denn die Basis b=128 verwendet in dem MINIMALISTISCHEN Ziffernstring exakt 128 Zeichen von einem Byte.
Noch einen Tick besser ist die Byte-Reduktion für b=129:
Basis für CPM : 129
BytesUTF8 : [0, 127, 1920, 61440, 1048576, 0]
BytesIndex : [0, 128, 16512, 1095423, 0]
ZiffernIndex : [0, 128, 16512, 1095423, 0]
Σ Bytes UTF8 : 4382591
Σ Bytes Index : 3319421
Diff (I - U) : -1063170 <== MIN -1.063.170
Quote (I : U) : 75.74%
==================================
Und hier der Test für ausgewählte Basis-Werte (b = 2**k, für k= 12, 11, …, 16)
Hinweis:
Ist ein Reduktionswert POSITIV, handelt es sich tatsächlich nicht um eine Reduktion, sondern um einen Mehraufwand.
Nur NEGATIVE Reduktionswerte bedeuten tatsächlich weniger Aufwand.
Dies wird auch klar durch Quote (I : U) = Quote (Index : UTF8)
Basis für CPM : 4096
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 129, 18432, 266253, 534529, 292721, 0]
ZiffernIndex : [0, 4096, 1107968, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 4437473
Diff (I - U) : 54881
Quote (I : U) : 101.25%
Reduktion : 1.25%
Basis für CPM : 2048
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 129, 18302, 297248, 796385, 0]
ZiffernIndex : [0, 2048, 1110016, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 4114017
Diff (I - U) : -268575
Quote (I : U) : 93.87%
Reduktion : -6.13%
Basis für CPM : 1024
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 129, 17149, 236481, 858305, 0]
ZiffernIndex : [0, 1024, 1045504, 65536, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 4177090
Diff (I - U) : -205502
Quote (I : U) : 95.31%
Reduktion : -4.69%
Basis für CPM : 512
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 129, 16379, 163334, 492155, 440067, 0]
ZiffernIndex : [0, 512, 259584, 851968, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 4691844
Diff (I - U) : 309252
Quote (I : U) : 107.06%
Reduktion : 7.06%
Basis für CPM : 256
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 129, 16639, 297863, 539369, 258064, 0]
ZiffernIndex : [0, 256, 63232, 1048576, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 4374792
Diff (I - U) : -7800
Quote (I : U) : 99.82%
Reduktion : -0.18%
Basis für CPM : 128
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 128, 16256, 1095680, 0]
ZiffernIndex : [0, 128, 16256, 1095680, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 3319680
Diff (I - U) : -1062912
Quote (I : U) : 75.75%
Reduktion : -24.25%
Basis für CPM : 64
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 64, 4032, 256000, 851968, 0]
ZiffernIndex : [0, 64, 4032, 256000, 851968, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 4184000
Diff (I - U) : -198592
Quote (I : U) : 95.47%
Reduktion : -4.53%
Basis für CPM : 32
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 32, 992, 31744, 1013760, 65536, 0]
ZiffernIndex : [0, 32, 992, 31744, 1013760, 65536, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 4479968
Diff (I - U) : 97376
Quote (I : U) : 102.22%
Reduktion : 2.22%
Basis für CPM : 16
BytesUTF8 : [0, 128, 1920, 61440, 1048576, 0]
BytesIndex : [0, 16, 240, 3840, 59392, 983040, 65536, 0]
ZiffernIndex : [0, 16, 240, 3840, 59392, 983040, 65536, 0]
Σ Bytes UTF8 : 4382592
Σ Bytes Index : 5558000
Diff (I - U) : 1175408
Quote (I : U) : 126.82%
Reduktion : 26.82%
Aber vielleicht sind das alles ja nur wilde Spekulationen?
Wolfgang Büchel
=======================
Das verwendete Python-Programm:
ziffern = ''.join([ chr(x) for x in range(0, 4097) ])
for k in range(12, 3, -1):
basis = 2**k
countBytes_UTF8_CPM(basis, ziffern)
===============================
def countBytes_UTF8_CPM(basis, ziffern, zeigen=False):
"""
Ermittelt die Gesamtzahl der 8-Bit-Bytes
-- aller UTF8-Zeichen <ch> von 1 bis Max_UTF8 = 1.114.111
-- aller aus <ch> via ord(ch) berechneten Indexzahlzeichen
für den Ziffernstring <ziffern> der Länge <basis> nach CPM
(sowie deren Ziffernanzahl)
und vergleicht diese beiden Byte-Anzahlen.
"""
Max_UTF8 = 1114111
ziffern = ziffern[:basis] # Ziffernstring für Positionssystem CPM
basis = len(ziffern) # Basis dieses Positionssystems
print("\nBasis für CPM : %s" % basis)
# Zähler für die ANZAHL der Bytes ...
cnt_UTF8 = [0] * 6 # ... in UTF8-Zeichen ch
cnt_Index_Bytes = [0] * 25 # ... in Index-Zahlzeichen <index>
# cnt_UTF8[i] = ANZAHL der UTF8-Zeichen mit i Byte
# cnt_Index8[i] = ANZAHL der index-Zeichen mit i Byte
# BytesUTF8 : [0, 127, 1920, 61440, 1048576, 0] bedeutet:
# UTF8 hat 0 0-Byte-Zeichen,
# 127 1-Byte-Zeichen,
# 1920 2-Byte-Zeichen, etc.
# Zähler für die ANZAHL der Ziffern in Index-Zahlzeichen <index>
cnt_Index_Ziffern = [0] * 25
# cnt_Index_Ziffern : [0, 1023, 1045504, 65536]
# bedeutet:
# Index hat 1023 1-Ziffern-Zahlzeichen
# 1045504 2-Ziffern-Zahlzeichen
# 65536 3-Ziffern-Zahlzeichen, etc.
for i in range(1, 1 + Max_UTF8):
# SKIP 2048 surrogates-Zeichen;
# in diesem Teilbereich liegen unzulässige UTF8-Zeichen
if i in range(55296, 1 + 57343): continue
ch = chr(i)
index = nachsys(basis, i, ziffern)
numBytesUTF8 = len(bytes(ch, 'utf8'))
numBytesIndex = len(bytes(index, 'utf8'))
cnt_UTF8[numBytesUTF8] += 1
cnt_Index_Bytes[numBytesIndex] += 1
cnt_Index_Ziffern[len(index)] += 1
if zeigen:
if numBytesIndex == 3:
print("[%7d] >%s< >>%s<< " % (i, ch, index))
# Listen-End-Elemente mit Wert 0 abschneiden, ausgenommen das letzte
while cnt_Index_Bytes[-2] == 0:
cnt_Index_Bytes = cnt_Index_Bytes[:-1]
while cnt_Index_Ziffern[-2] == 0:
cnt_Index_Ziffern = cnt_Index_Ziffern[:-1]
# Summenberechnung für die Gesamtzahl der Bytes cnt_UTF8 und cnt_Index
sum_BytesU = sum([ i*cnt_UTF8[i] for i in range(len(cnt_UTF8)) ])
sum_BytesI = sum([ i*cnt_Index_Bytes[i] for i in range(len(cnt_Index_Bytes)) ])
diff = sum_BytesI - sum_BytesU
quote = 100*sum_BytesI / sum_BytesU
print("BytesUTF8 : %s" % cnt_UTF8)
print("BytesIndex : %s" % cnt_Index_Bytes)
print("ZiffernIndex : %s" % cnt_Index_Ziffern)
print("Σ Bytes UTF8 : %7d" % sum_BytesU)
print("Σ Bytes Index : %7d" % sum_BytesI)
print("Diff (I - U) : %d" % diff)
print("Quote (I : U) : %0.2f%%" % quote)
print("Reduktion : %0.2f%%" % (quote-100))
[View Less]
