Drücken Sie „Enter“, um den Inhalte zu überspringen

Zeichen und Zeichenketten

In diesem Abschnitt soll noch einmal intensiver auf Zeichen und Zeichenketten aus dem Bereich der Basisdatentypen eingegangen werden. Zeichenketten nehmen in den verschiedenen Programmiersprachen dabei gerne Sonderrollen ein, in denen sie eher zu den komplexeren Datentypen gezählt werden. Wir wollen hier aber jetzt diesen Punkt nicht weiter vertiefen und schauen stattdessen auf die einzelnen Operatoren und Funktionen, bzw. Methoden, die von den beiden Datentypen in der Programmiersprache Python zur Verfügung gestellt werden.

Operatoren

Kann ich mit Zeichen oder Zeichenketten rechnen? Die Antwort lässt sich sehr einfach geben: JA! Aber wenn wir die aus der Schule bekannten Grundrechenarten betrachten, stellt sich schnell die Frage, wie das genau gehen soll und was das Ergebnis einer solchen Rechenoperation ist.

Der +-Operator

s = 'Hello'
t = 'World'

print(s + t)

Schauen wir uns zunächst die Addition zweier Zeichen oder Zeichenketten an. Werden in Python zwei Zeichen oder Zeichenketten miteinander addiert, so entsteht eine neue Zeichenkette, in der beide Zeichen oder Zeichenketten hintereinander gereiht werden:

Der *-Operator

Die Addition mag möglicherweise vorhersehbar gewesen sein. Aber lassen sich auch Zeichen oder Zeichenketten multiplizieren? Auch diese Antwort ist einfach: JA!

s = '~'
print (s * 20)

Bei der Multiplikation eines Zeichens oder einer Zeichenkette mit einer Ganzzahl (integer) werden die Zeichen um die genannte Anzahl vervielfältigt. In diesem Fall wird das Zeichen ‚~‘ zwanzigmal hintereinander ausgegeben.

Und lassen sich auch zwei Zeichen oder Zeichenketten miteinander multiplizieren? Leider nein. An dieser Stelle stoßen die Rechenoperationen bei Zeichen oder Zeichenketten an ihre Grenzen:

Der in-, bzw. not in-Operator

Es gibt aber noch zwei weitere Operatoren, mit denen sich einfach das Vorhandensein von Zeichen oder Zeichenketten in einer anderen Zeichenkette überprüfen lassen. Das Ergebnis dieser „Rechenoperation“ ist vom Typ Boolean und liefert entsprechend True oder False als Ergebnis:

s = 'Hello World'
t = 'll'

print (t in s)

Die hier gezeigte Operation prüft, ob die Zeichenfolge ‚ll‘ in der Zeichenkette ‚Hello World“ vorhanden ist. Das Ergebnis ist, wie erwartet, True.

In ähnlicher Art und Weise lässt sich hier auch das Nicht-Vorhandensein von Zeichen oder Zeichenketten in einer Zeichenkette überprüfen:

s = 'Hello World'
t = 'x'

print (t not in s)

Auch dieses Ergebnis wird niemanden verwundern: Das Zeichen ‚x‘ kommt in der Zeichenkette ‚Hello World‘ nicht vor.

Funktionen

Die Programmiersprachen Python bietet für den Umgang mit Zeichen und Zeichenketten eine Reihe eingebauter Funktionen, die wir im Folgenden uns genauer betrachten wollen:

ord(s) und chr(i)

Um die beiden Funktionen ord(s) und chr(i) verstehen zu können, müssen wir uns zunächst anschauen, wie die einzelnen Zeichen im Computer verwaltet werden. Grundlage ist hier der ‚American Standard Code for Information Interchange‚, abgekürzt ASCII. Als Fortführung der Codierung bei der Telegrafie sollte im Jahr 1960 eine neue Form der Kodierung auf Grundlage eines 7-Bit Musters erschaffen werden. Hierbei sollte jedem Zeichen des englischen Alphabets, sowie Ziffern und Sonderzeichen eine 7-stellige Folge von 0 und 1 zugewiesen werden. Mit den 7 Bit lassen sich so 128 Zeichen mit Folgen von 0 und 1 darstellen. Das Zeichen ‚A‘ beispielsweise wurde als Bitfolge ‚10000001‘, was der Zahl 65 entspricht, zugewiesen. In Folge dessen entspricht das Zeichen ‚B‘ der Bitfolge ‚1000010‘ (66) usw. Das Ergebnis wurde 1963 vorgestellt und ist bis heute internationaler Standard in der IT.

Die sogenannte ASCII-Tabelle wurde später um länderspezifische Sonderzeichen erweitert, in dem ein weiteres Bit hinzugenommen und die Kodierung auf 8-Bit erweitert wurde. Welche Zeichen hier aufgenommen wurden, wurde in jedem Land unabhängig voneinander entschieden. Für die länderspezifischen und weitere Sonderzeichen standen von nun weitere 128 Bitfolgen zur Verfügung. Das Zeichen ‚Ä‘ aus dem deutschen Alphabet ist beispielsweise mit der Bitfolge ‚11000100‘ an Position 196 zu finden. Auch das Euro-Zeichen ‚€‘ ist hier unter ‚10000000‘ (128) zu finden.

Irgendwann reichten im IT-Zeitalter auch diese nun auf 256 „Codes“ erweiterte Tabelle nicht mehr aus. Der Umgang mit verschiedenen, länderspezifischen Ausprägungen der ASCII-Tabelle erschwerten zunehmend die Softwareentwicklung. Vor allem dann, wenn die Software in mehreren Sprachen zur Verfügung gestellt werden sollte. Zwar wurden hier sogenannte „Codepages“ erfunden, doch stellten sich diese als Hindernis im internationalen Datenaustausch heraus. Aus diesem Grund wurde in den 1990er Jahren nach einer entsprechenden Erweiterung gesucht, was in der UTF-8 Kodierung endete. Die Abkürzung „UTF“ steht dabei für Unicode Transformation Format. Um eine möglichst große Kompatibilität zu erhalten, entsprechen die ersten 128 Zeichen in UTF-8 der standardisierten ASCII-Tabelle. Darüber hinaus stehen bei UTF-8 nun bis zu vier 8-Bit Folgen für die Zeichenkodierung zur Verfügung.

Mit UTF-8 lassen sich nun auch exotische Sonderzeichen, wie zum Beispiels die beliebten Emojis darstellen. Der grinsende Smiley (?) hat beispielsweise die Kodierung ‚11110000:10011111:10011000:10000000‘ bekommen, was der vereinfachten Schreibweise ‚U+1F600‘ entspricht.

So viel zum Exkurs in Zeichenkodierung. Was bedeutet das nun für die Funktionen ord(s) und chr(i) in der Programmiersprache Python?

Mit der Funktion ord(s) lässt sich die Position eines Zeichens in der UTF-8, respektive ASCII-Tabelle, ausgeben:

print(ord('A'))

Hierbei wird der Funktion der entsprechende Zeichen als Parameter übergeben. Das Ergebnis ist eine Integer-Zahl. So lässt sich zum Beispiel überprüfen, ob das Zeichen ‚A‘ tatsächlich an Stelle 65 der ASCII-Tabelle zu finden ist ;-).

Und das ganze funktioniert mit der Funktion chr(i) auch umgekehrt, wobei hier als Parameter die Position als Integer-Zahl übergeben wird und ein Zeichen (char) als Ergebnis herauskommt:

print(chr(67))

len(s)

Mit der Funktion len(s) lässt sich die Länge einer Zeichenkette bestimmen. Hierbei wird der Funktion die Zeichenkette als Parameter übergeben. Das Ergebnis ist eine Integer-Zahl, welche der Anzahl an Zeichen in der Zeichenfolge entspricht:

s = 'Hello World'

print (len(s))

str(i)

Die Programmiersprache Python unterscheidet zwischen verschiedenen Datentypen. Operationen zwischen verschiedenen Datentypen sind nur unter bestimmten Bedingungen möglich, wenn die Datentypen der selben „Familie“ entsprechen. Die Addition, genauer hier die Verkettung, einer Zeichenkette mit einer Ganzzahl (Integer) resultiert in einer Fehlermeldung:

Um dennoch eine Zeichenkette mit einer Zahl zu addieren, lässt sich die Zahl mit der Funktion str(i) in eine entsprechende Zeichenfolge umwandeln.

a = str(5)    # a ist nun '5'
b = str(3.14) # b ist nun '3.14'

Positionen (Index) von Zeichen in Zeichenfolgen

Zeichenketten nehmen in den verschiedenen Programmiersprachen gerne eine Sonderrolle unter den Basisdatentypen ein. So lässt sich beispielsweise eine Zeichenkette auch als Liste von Zeichen verstehen. Und wie bei einer Liste kann auch in Zeichenketten auf einzelne Zeichen unter Angabe ihrer Position, ihres Indexes, zugegriffen werden, wobei der Index immer mit 0 beginnt:

s = 'Hello World'
print (s[6])

Textauszüge

Auch aus Zeichenketten lassen sich, wie in Listen, Teillist oder hier Textauszüge, bilden. Hierzu werden auch hier in den eckigen Klammern die Start- und die Endeposition durch ein : getrennt festgelegt. Start- oder Endeposition können auch weggelassen werden. Fehlt die Startposition, wird implizit als Startposition der Wert 0 angenommen. Wird keine Ende-Position angegeben, so beginnt der Textauszug mit der angegebenen Startposition und endet mit dem letzten Element der Zeichenkette.

Interpolation

Sollen mehrere Variablen in eine Zeichenkette eingebettet werden, so kann die Umwandlung der Zahlenvariablen in Zeichenketten und die dann folgende Addition mehrere Zeichenketten unübersichtlich und aufwändig werden. Die Programmiersprache Python bietet hier eine elegante Möglichkeit, dies zu vereinfachen. Hierzu muss eine Zeichenkette mit dem Zeichen ‚f‘ eingeleitet werden. Die Variablen werden anschließend in die Zeichenkette eingebettet, in dem sie mit runden Klammern versehen werden :

a = 'Andreas'
b = 42
s = f'Mein Name ist {a} und ich bin {b} Jahre alt.'

print (s)
Share This

Share This

Share this post with your friends!