Escape-Sequenzen in Python-Strings          (C) 2016-2020 T.Birnthaler OSTC GmbH
==================================

Doku --> docs.python.org/3/reference/lexical_analysis.html#literals

Das Zeichen "\" (Backslash) dient in Python innerhalb von Strings als
"Fluchtzeichen" (Escape-Zeichen), das zusammen mit dem direkt folgenden
Zeichen eine spezielle Bedeutung hat. Darüber werden Steuerzeichen und
Zeichen über ihre Codierung angesprochen.

Folgende Kombinationen sind möglich:

  +--------------+----------------------------------------------------------+
  | Zeichen      | Bedeutung                                                |
  +--------------+----------------------------------------------------------+
  | \\           | Backslash                                                |
  | \'           | Hochkomma                                 [single quote] |
  | \"           | Gänsefüßchen                              [double quote] |
  +--------------+----------------------------------------------------------+
  | \a           | Klingel (BEL)                                    [alert] |
  | \b           | Rückschritt (BS)                             [backspace] |
  | \f           | Seitenvorschub (FF)                          [form feed] |
  | \n           | Zeilenumbruch (LF)                   [newline, linefeed] |
  | \r           | Wagenrücklauf (CR)                     [carriage return] |
  | \t           | Horizontaler Tabulator (HT)                  [tabulator] |
  | \v           | Vertikaler Tabulator (VT)           [vertical tabulator] |
  +--------------+----------------------------------------------------------+
  | \ooo         | Zeichen mit Oktalcode "ooo" (000-777)            [octal] |
  | \xhh         | Zeichen mit Hexadezimalcode "hh" (00-ff)   [hexadezimal] |
  | \N{name}     | Zeichen mit Unicode-Name "name"                   [Name] |
  | \uxxxx       | Zeichen mit 16-bit Unicode-Wert "xxxx"         [unicode] |
  | \Uxxxxxxxx   | Zeichen mit 32-bit Unicode-Wert "xxxxxxxx"     [Unicode] |
  +--------------+----------------------------------------------------------+
  | \<NL>        | Zeilenfortsetzung [line continuation]                    |
  +--------------+----------------------------------------------------------+

HINWEISE:

* Innerhalb von Raw-Strings r"..." werden Escape-Sequenzen nicht interpretiert
  sondern bleiben stehen.

* Ein Backslash am Zeilenende ("Line Continuation") verknüpft die aktuelle
  Zeile mit der folgenden zu einer "logischen Zeile" und erlaubt so eine
  beliebige Unterteilung von langen Zeilen in kurze Stücke. Die Einrückung der
  Folgezeile ist dabei irrelevant und muss nicht den Einrückungsregeln von
  Python gehorchen.

    erg = 1 + 2 + 3

Zeichenketten werden durch folgende Syntax definiert (quotiert):

  +----------------+-----+-------------------------------------------------+
  | Syntax         |     | Bedeutung                                       |
  +----------------+-----+-------------------------------------------------+
  | "..."          | E 1 | Alle Zeichen (außer " und Zeilenvorschub)       |
  | '...'          | E 1 | Alle Zeichen (außer ' und Zeilenvorschub)       |
  | """..."""      | E m | Alle Zeichen (inklusive " ' und Zeilenvorschub) |
  | '''...'''      | E m | Alle Zeichen (inklusive " ' und Zeilenvorschub) |
  +----------------+-----+-------------------------------------------------+
  | r"..."  R"..." | - 1 | Raw-String (Escape-Sequenz nicht interpretiert) |
  | b"..."  B"..." | E 1 | Binär-String (STD in P3)                        |
  | u"..."  U"..." | E 1 | Unicode-String (STD in P2)                      |
  | f"..."  F"..." | E 1 | Format-String mit Platzhalter {VAR}             |
  +----------------+-----+-------------------------------------------------+
    E = Escape-Sequenz \X wird interpretiert
    - = Escape-Sequenz \X bleibt stehen (2 Zeichen)
    1 = Nur einzeiliger String möglich
    m = Mehrzeiliger String erlaubt

HINWEIS:

* String-Literale, die DIREKT aufeinander folgen, werden automatisch verkettet
  (das Verkettungszeichen "+" dazwischen ist nicht notwendig):

    "hallo" "welt" 'usw.'            # --> 'halloweltusw.'
    "hallo" + "welt" + 'usw.'        # --> 'halloweltusw.'
    "hallo" ' ' "welt" ' ' "usw."    # --> 'hallo welt usw.'

BEISPIELE:

  print("Hallll\b\bo\t\\Welt")       # --> 'Hallo    \Welt'
  print('Hallll\b\bo\t\\Welt')       # --> 'Hallo    \Welt'
  print('''Hallll\b\bo\t\\Welt''')   # --> 'Hallo    \Welt'
  print("""Hallll\b\bo\t\\Welt""")   # --> 'Hallo    \Welt'
  print(r"Hallll\b\bo\t\\Welt")      # --> 'Hallll\b\bo\t\\Welt'    raw-String
  print(R"Hallll\b\bo\t\\Welt")      # --> 'Hallll\b\bo\t\\Welt'    raw-String
  print("Hallo \                     # Zeilenfortsetzung im String
         Welt")                      # (\n unterdrückt, Präfix 2. Zeile dabei)
  print("Hallo " + \                 # Zeilenfortsetzung im Code
        "Welt")                      # (\n und Präfix 2. Zeile unterdrückt)
  print("Hallo " "Welt")             # --> 'Hallo Welt' (automatische Verkettung)
  print("Hallo " + "Welt")           # --> 'Hallo Welt' (explizite Verkettung)

  "\u03C0 \U000003C0 \N{GREEK SMALL LETTER PI}"                  # --> 'π π π'
  "\u03A0 \U000003A0 \N{GREEK CAPITAL LETTER PI}"                # --> 'Π Π Π'
  "\u00E4 \U000000E4 \N{LATIN SMALL LETTER A WITH DIAERESIS}"    # --> 'ä ä ä'
  "\u00F6 \U000000F6 \N{LATIN SMALL LETTER O WITH DIAERESIS}"    # --> 'ö ö ö'
  "\u00FC \U000000FC \N{LATIN SMALL LETTER U WITH DIAERESIS}"    # --> 'ü ü ü'
  "\u00DF \U000000DF \N{LATIN SMALL LETTER SHARP S}"             # --> 'ß ß ß'
  "\u00C4 \U000000C4 \N{LATIN CAPITAL LETTER A WITH DIAERESIS}"  # --> 'Ä Ä Ä'
  "\u00D6 \U000000D6 \N{LATIN CAPITAL LETTER O WITH DIAERESIS}"  # --> 'Ö Ö Ö'
  "\u00DC \U000000DC \N{LATIN CAPITAL LETTER U WITH DIAERESIS}"  # --> 'Ü Ü Ü'
  "\u00D7 \U000000D7 \N{MULTIPLICATION SIGN}"                    # --> '× × ×'