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

Doku --> docs.python.org/3/reference/lexical_analysis.html#literals
         docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-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 z.B. Steuerzeichen (Strg-Z) und
Unicode-Zeichen über ihre Codierung oder ihren Namen angesprochen.

Folgende Kombinationen sind möglich:

  +--------------+----------------------------------------------------------+
  | Zeichen      | Bedeutung                                                |
  +--------------+----------------------------------------------------------+
  | \\           | Backslash                                    [backslash] |
  | \'           | Hochkomma (in '...' notwendig)            [single quote] |
  | \"           | Gänsefüßchen (in "..." notwendig)         [double quote] |
  +--------------+----------------------------------------------------------+
  | \a           | Klingel (BEL)                                    [alert] |
  | \b           | Rückschritt (BS)                             [backspace] |
  | \e           | Escape (ESC)                                    [escape] |
  | \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] |
  +--------------+----------------------------------------------------------+
  | \0           | Null Byte (NUL)                                   [null] |
  | \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] |
  +--------------+----------------------------------------------------------+
  | \<NEWLINE>   | Zeilenende wird ignoriert            [line continuation] |
  | \<SONST>     | Bleibt stehen inkl. Backslash                            |
  +--------------+----------------------------------------------------------+

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) |
  +-----------------+-----+-------------------------------------------------+
  | b"..."  B"..."  | E 1 | Binär-String (STD in P2)                        |
  | f"..."  F"..."  | E 1 | Format-String mit Platzhaltern der Form {...}   |
  | r"..."  R"..."  | - 1 | Raw-String (Escape-Sequenz nicht interpretiert) |
  | u"..."  U"..."  | E 1 | Unicode-String (STD in P3)                      |
  +-----------------+-----+-------------------------------------------------+
  | ur"..." UR"..." | - 1 | Raw-String im Unicode-Format                    |
  | ru"..." RU"..." | - 1 | Raw-String im Unicode-Format                    |
  | fr"..." FR"..." | - 1 | Raw-Format-String                               |
  | rf"..." RF"..." | - 1 | Raw-Format-String                               |
  | br"..." BR"..." | - 1 | Raw-Binär-String                                |
  | rb"..." RB"..." | - 1 | Raw-Binär-String                                |
  +-----------------+-----+-------------------------------------------------+
    E = Escape-Sequenz \X wird interpretiert
    - = Escape-Sequenz \X bleibt stehen (2 Zeichen)
    1 = Nur einzeiliger String möglich
    m = Mehrzeiliger String sowie ' und " im 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.'

  Dies gilt auch dann, wenn die String-Literale auf mehrere Zeilen verteilt sind:

    "hallo"    # --> "halloweltusw."
    "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}"                    # '× × ×'
  "\u4e14 \U00004e14 \N{CJK UNIFIED IDEOGRAPH-4E14}"             # '且 且 且'
  "\U0001f970 \N{'SMILING FACE WITH SMILING EYES AND THREE HEARTS'}"  # '🥰 🥰'

  hex(ord('π'))                 # '03c0'
  hex(ord('\u03C0'))            # '03c0'
  ord('π')                      # 960
  ord('\u03C0')                 # 960
  chr(0x03C0)                   # 'π'
  chr(960)                      # 'π'
  chr(int('03C0', 16))          # 'π'
  chr(int('0x03C0', 0))         # 'π'

  import unicodedata            # Modul importieren
  unicodedata.name('\u03A0')    # 'GREEK CAPITAL LETTER PI'
  unicodedata.name('\u03C0')    # 'GREEK SMALL LETTER PI'