NoPaste

Regexp-Kurs_02.R

von tegula
SNIPPET_DESC:
Bitte Dateinamensendung ".txt" entfernen.
SNIPPET_CREATION_TIME:
13.04.2022 17:04:43
SNIPPET_PRUNE_TIME:
Unendlich

SNIPPET_TEXT:
  1. #' ---
  2. #' title: "Lösungsversuch zum RegEXP-Kurs im Debianforum"
  3. #' author: "tegula"
  4. #' date: "10 4 2022"
  5. #' output: html_document
  6. #' ---
  7.  
  8. #' ------------------------
  9. #' ------------------------
  10.  
  11. #' **Kurs-Teil:** 02 - Metazeichen & Escaping (09.04.2022)  
  12. #' **URL:** https://debianforum.de/forum/viewtopic.php?t=183974  
  13.  
  14. #' ------------------------
  15. #' ------------------------  
  16.  
  17.  
  18.  
  19. #' Vorbereitung --> Zusätzliche Packages laden:
  20. library(magrittr)  # für Pipe-Operator
  21. library(stringr)   # für das "Zerstückeln" der Zeichenketten
  22. library(docstring) # für Beschreibung bzw. Kurzhilfe der selbstdefinierten Funktionen
  23. #' ------------------------
  24. #' ------------------------
  25.  
  26.  
  27.  
  28. # Aufgabe 1) Das Escapezeichen ist der Unterstrich (_). Literale Zeichen sind die Standardzeichen. Schreibe den Ausdruck fuer das literale Wort: ``Haus''.  
  29.  
  30. #' **Antwort:** Haus
  31.  
  32. #' ------------------------
  33. #' ------------------------
  34.  
  35.  
  36.  
  37. # Aufgabe 2) Das Escapezeichen ist der Unterstrich (_). Metazeichen sind die Standardzeichen. Schreibe den Ausdruck fuer das literale Wort: ``Haus''.
  38. #' **Antwort:** _H_a_u_s
  39.  
  40. #' ------------------------
  41. #' ------------------------
  42.  
  43. # Aufgabe 3) Das Escapezeichen ist das grosse X. Metazeichen sind die Standardzeichen. Schreibe den Ausdruck fuer das literale Wort: ``Haus''.  
  44. #' **Antwort:** XHXaXuXs  
  45.  
  46. #' ------------------------
  47. #' ------------------------
  48.  
  49. ## Aufgabe 4) Das Escapezeichen ist das kleine a. Literale Zeichen sind die Standardzeichen. Schreibe den Ausdruck fuer das literale Wort: ``Haus'  
  50. #' **Antwort:** aHaaauas  
  51.  
  52. #' ------------------------
  53. #' ------------------------
  54.  
  55.  
  56. ## Aufgabe 5.) Suche dir ein Escapezeichen aus. Literale Zeichen sind die Standardzeichen. Schreibe die Zeichenfolge: Literales `D', literales 'F', literales `D', literales 'E', Metazeichen `J', literales `R', literales `E', literales `s', literales `!', Metazeichen `J', Metazeichen `@'.  
  57.  
  58. #' **Gewähltes Escapezeichen**: _Einfaches_ Escapezeichen (im R-Script doppelt geschrieben, damit bei Generierung des Reports (R-Markdown-Dokument) (einfach statt gar nicht) angezeigt wird.  
  59. #' **Antwort:** DFDE\\JREs!\\J\\@    
  60.  
  61. #' ------------------------
  62. #' ------------------------
  63.  
  64. ## Aufgabe 6) Schreibe den gleichen Text aus (5) [Aufgabe 5] aber mit Metazeichen als Standardzeichen.  
  65. #' **Antwort:** \\D\\F\\D\\EJ\\R\\E\\s\\J@  
  66.  
  67. #' ------------------------
  68. #' ------------------------
  69.  
  70. ## Aufgabe 7) Das Escapezeichen ist die oeffnende runde Klammer (`('). Suche dir aus, welche Zeichenart die Standardzeichen sind. Schreibe einen Ausdruck mit nur oeffnenden und schliessenden runden Klammern und erklaere ihn anschliessend
  71.  
  72. #' **Antwort:**  
  73. #' * Standardzeichen = Literale Zeichen
  74. #' * Es ergibt sich folgende Zeichenkette: "(())". Gelesen von links nach rechts: [Klammer auf als Escapezeichen], Klammer auf, [Klammer auf als Escapezeichen], Klammer auf, Klammer zu, Klammer zu".  
  75.  
  76. #' ------------------------
  77. #' ------------------------
  78.  
  79. ## Aufgabe 8) Das Escapezeichen ist das Komma (,). Literale Zeichen sind die Standardzeichen. Beschreibe den Ausdruck (vgl. (5)): ``A,BCD,E,FG,,H''  
  80.  
  81. #' **ANTWORT**  
  82. #' * __Von links nach rechts (komplette Zeichenkette, einschließlich Metazeichen):__ literales Zeichen "A", Metazeichen "B", literales Zeichen "C", literales Zeichen "D", Metazeichen "E", Metazeichen "F", literales Zeichen G, Metazeichen ",", literales Zeichen H.  
  83. #' * __"Lesbare" Zeichenkette (ohne Metazeichen):__ "ACDGH".  
  84.  
  85. #' ------------------------
  86. #' ------------------------
  87.  
  88. # Aufgabe 9)Das Escapezeichen ist das Komma (,). Metazeichen sind die Standardzeichen. Beschreibe den Ausdruck: ``hello, world''  
  89. #' **ANTWORT**  
  90. #' * __Von links nach rechts (komplette Zeichenkette, einschließlich Metazeichen):__ Metazeichen "h", Metazeichen "e", Metazeichen "l", Metazeichen "l", Metazeichen "o", literales Zeichen " ", Metazeichen "w", Metazeichen "o", Metazeichen "r", Metazeichen "l", Metazeichen "d".    
  91. #' * __"Lesbare" Zeichenkette (ohne Metazeichen):__ " ".  
  92.  
  93. #' ------------------------
  94. #' ------------------------
  95.  
  96.  
  97. # Aufgabe 10) Das Escapezeichen ist das kleine a. Literale Zeichen sind die Standardzeichen. Beschreibe den Ausdruck: ``Haus''
  98. #' **ANTWORT**    
  99. #' * __Von links nach rechts (komplette Zeichenkette, einschließlich Metazeichen):__  Literales Zeichen "H", Metazeichen "u", literales Zeichen "s".  
  100. #' * __"Lesbare" Zeichenkette (ohne Metazeichen):__ "Hs"  
  101.  
  102. #' ------------------------
  103. #' ------------------------
  104.  
  105. # Aufgabe 11) Das Escapezeichen ist das kleine a. Literale Zeichen sind die Standardzeichen. Beschreibe den Ausdruck: ``Haaus''
  106. #' **ANTWORT**      
  107. #' * __Von links nach rechts (komplette Zeichenkette, einschließlich Metazeichen):__ Literales Zeichen "H", Metazeichen a, literales Zeichen u, literales Zeichen s.  
  108. #'* __"Lesbare" Zeichenkette (ohne Metazeichen):__ "Hus"  
  109.  
  110. #' ------------------------
  111. #' ------------------------
  112.  
  113. # Aufgabe 12) Das Escapezeichen ist das kleine a. Metazeichen sind die Standardzeichen. Beschreibe den Ausdruck: ``Haaus''
  114. #' * __Von links nach rechts (komplette Zeichenkette, einschließlich Metazeichen):__ Metazeichen "H", literales Zeichen "a", Metazeichen "u", Metazeichen "s".  
  115. #' * __"Lesbare" Zeichenkette (ohne Metazeichen):__ "a"  
  116.  
  117. #' ------------------------
  118. #' ------------------------
  119.  
  120. # Aufgabe 13) Schreibe ein Programm, das literalen Text passend escapet. Das Escapezeichen und die Entscheidung, welche Zeichenart die Standardzeichen sind, sollen variabel sein (z.B. CLI-Argumente). Pruefe damit deine Loesungen fuer die Aufgaben (1) bis (7).
  121.  
  122. #' **Funktion definieren:**  
  123.  
  124.  
  125. escapen <- function(txt, escape, standard) {
  126.  
  127.   #' escapen
  128.   #'
  129.   #' Nimmt die Beschreibung eines regulären Ausdruck als character-Objekt (literales Wort) bzw. data.frame-Objekt (Beschreibung der im Ausdruck enthaltenen Zeichen, ihres Zeichentyp (Standardzeichen oder Metazeichen) sowie ihrer Reihenfolge) entgegen und gibt (abhängig von gewählten Escapezeichen) einen regulären Ausdruck (als Character-Objekt) zurück.
  130.   #'
  131.   #' @param txt Entweder ein chr-Obekt der Länge 1 (als Repräsentation eines (ausschließlich) literalen Worts) oder ein data.frame-Objekt (als Repräsentation eines Ausdrucks, welcher (gleichzeitig) sowohl literale Zeichen als auch Metazeichen enthalten kann). Wird ein data.frame-Objekte übergeben, so muss dieses zwingend die chr-Variablen (Spalten) 'zeichen' (--> erlaubte Werte: Genau ein (!) (beliebige) Zeichen) und 'typ' (--> erlaubte Werte: "literal" und "meta") enthalten. Jedes Zeichen des Ausdrucks muss durch genau einen Fall (Zeile) im data.frame-Objekt beschrieben werden.
  132.   #' @param escape chr-Objekt der Länge 1: Escapezeichen.
  133.   #' @param standard chr-Obekt der Länge 1: Entweder "literal" (Standardzeichen sind die literalen Zeichen) oder "meta" (Standardzeichen sind die Metazeichen).
  134.   #' @return chr-Objekt der Länge 1: Regulärer Ausdruck, abhängig von {txt}, {escape} und {standard}.
  135.   #' @examples escapen(txt = "hallo", escape = "X", standard = "meta") # Literales Wort ist "hallo". Escapezeichen ist das "X". Standardzeichen sind die Metazeichen.
  136.   #' @export
  137.  
  138.  
  139.   ## Fall 1: Alle Zeichen sind literale Zeichen (eigentlich: die Benutzereingabe ist eine Zeichenkette)  & Standardzeichen = Metazeichen.
  140.   ### --> Vor jedes Zeichen des literalen Worts wird das (im Funktionargument "escape" anzugebende) Escapezeichen eingefügt.
  141.   if ((is.character(txt)) & (standard == "meta"))  {
  142.     txt %>%
  143.       stringr::str_extract_all(pattern = "[:print:]", simplify = TRUE) %>%
  144.       paste0(collapse = escape) %>%
  145.       paste0(escape, .) %>%
  146.       return() # "fertigen" regulären Ausdruck zurückgeben
  147.     ### Fall 2: Alle Zeichen sind literale Zeichen (eigentlich: die Benutzereingabe ist eine Zeichenkette) & Standardzeichen = literale Zeichen.
  148.   } else if ((is.character(txt)) & (standard == "literal")) {
  149.     txt %>%
  150.       stringr::str_extract_all(pattern = "[:print:]", simplify = TRUE) %>%
  151.       paste0(collapse = "") %>%
  152.       return() # "fertigen" regulären Ausdruck zurückgeben
  153.     ## Fall 3: Zeichen gemischt (oder nur Metazeichen) & Standardzeichen = literale Zeichen.
  154.   } else if ((is.data.frame(txt)) & standard == "literal") {
  155.     ### Dem Datensatz (txt) wird eine zusätzliche (Character-)Variable (txt$escapezeichen) hinzugefügt. Ist das Zeichen ein Metazeichen, so wird der Variable txt$escapezeichen das Escapezeichen (Parameter "escape") zugewiesen. Ist das Zeichen ein literales Zeichen, so wird der Variable txt$escapezeichen eine leere Zeichenkette ("") zugewiesen.
  156.     txt$escapezeichen <- ifelse(test = (txt$typ=="meta"),
  157.                                 yes = escape,
  158.                                 no = "")
  159.     zeichenfolge <- ""
  160.     ### Erzeugen des Regulären Ausdrucks. Hierzu wird mit einer leeren Zeichenfolge begonnen. Anschließend werden alle Zeilen des Datensatzes (txt) durchlaufen.
  161.     for (i in seq(nrow(txt))) {
  162.     zeichenfolge <- paste0(zeichenfolge,
  163.                              txt$escapezeichen[i],
  164.                              txt$zeichen[i])
  165.     }
  166.     ### "fertigen" regulären Ausdruck zurückgeben
  167.     zeichenfolge %>% return()
  168.     ## Fall 4: Zeichen gemischt oder nur Metazeichen (eigentlich: Benutzereingabe ist ein data.frame-Objekt) & Standardzeichen = Metazeichen.
  169.     ### Dem Datensatz (txt) wird eine zusätzliche (Character-)Variable (txt$escapezeichen) hinzugefügt. Ist das Zeichen ein literales Zeichen, so wird der Variable txt$escapezeichen das Escapezeichen (Parameter "escape") zugewiesen. Ist das Zeichen ein Metazeichen, so wird der Variable txt$escapezeichen eine leere Zeichenkette ("") zugewiesen
  170.   } else if ((is.data.frame(txt)) & standard == "meta") {
  171.     txt$escapezeichen <- ifelse(test = (txt$typ == "literal"),
  172.                                 yes = escape,
  173.                                 no = "")
  174.     ### Erzeugen des regulären Ausdrucks. Hierzu wird mit einer leeren zeichenfolge begonnen. Anschließend werden alle Zeilen des Datensatzes (txt) durchlaufen.
  175.     zeichenfolge = ""
  176.     for (i in seq(nrow(txt))) {
  177.       zeichenfolge <- paste0(zeichenfolge,
  178.                              txt$escapezeichen[i],
  179.                              txt$zeichen[i])
  180.     }
  181.     ### "fertigen" regulären Ausdruck zurückgeben
  182.     zeichenfolge %>% return()
  183.     ### Sonstige Fälle: Treffen Fall 1-4 allesamt nicht zu, so wird Missing Value (NA) zurückgeben.
  184.   } else {
  185.     NA %>% return()
  186.   }
  187. }
  188.  
  189. #' **Lösungen überprüfen: --> Aufgabe 1:**  
  190. escapen(txt = "Haus", escape = "_", standard = "literal")
  191.  
  192. #' **Lösungen überprüfen -->  Aufgabe 2:**  
  193. escapen(txt = "Haus", escape = "_", standard = "meta")
  194.  
  195. #' **Lösungen überprüfen -->  Aufgabe 3:**  
  196. escapen(txt = "Haus", escape = "X", standard = "meta")
  197.  
  198. #' **Lösungen überprüfen -->  Aufgabe 4:**  
  199. escapen(txt = "Haus", escape = "X", standard = "meta")
  200.  
  201. #' **Lösungen überprüfen -->  Aufgabe 5:**  
  202.  
  203. #df_Aufgabe_5 <- edit(as.data.frame(NULL))
  204. #save(df_Aufgabe_5, file = "df_Aufgabe_5.RData", ascii = TRUE)
  205. load("df_Aufgabe_5.RData") # manuell eingetippte Daten laden
  206. df_Aufgabe_5 # manuell eingetippte Daten anzeigen
  207. escapen(txt = df_Aufgabe_5, escape = "\\", standard = "literal") # eigentliches Überprüfen der Lösung zu Aufgabe 5
  208.  
  209.  
  210. #' **Lösungen überprüfen -->  Aufgabe 6:**  
  211. escapen(txt=df_Aufgabe_5, escape = "\\", standard = "meta") # Gleiche Zeichen wie in Aufgabe 5. Einziger Unterschied: Standardzeichen sind die Metazeichen (statt der literalen Zeichen).
  212.  
  213. #' **Lösungen überprüfen -->  Aufgabe 7:**  
  214. #df_Aufgabe_7 <- edit(as.data.frame(NULL))
  215. #save(df_Aufgabe_7, file = "df_Aufgabe_7.RData", ascii = TRUE)
  216. load("df_Aufgabe_7.RData") # manuell eingetippte Daten anzeigen
  217. df_Aufgabe_7 # manuell eingetippte Daten anzeigen
  218. escapen(txt = df_Aufgabe_7, escape = "(", standard = "literal")  #eigentliches Überprüfen der Lösung zu Aufgabe 7
  219.  
  220. # Aufgabe 14) Auf die vorigen Aufgabe aufbauend: Schreibe ein Programm, das den escapeten Text wieder einliest und eine sprachliche Beschreibung davon ausgibt, aehnlich wie in (5). Pruefe damit deine Loesungen fuer die Aufgaben (8) bis (12).
  221. #' **Funktion definieren:**  
  222. beschreiben <- function(ausdruck, escape, standard) {
  223.   #' beschreiben
  224.   #'
  225.   #' Liest ein Character-Objekt (als Repräsentation eines regulären Ausdrucks) ein und gibt (abhängig von der angegebenen Definition von Standard- und Escapezeichen) eine passende sprachliche Beschreibung (ebenfalls als Character-Objekt) zurück.
  226.   #'
  227.   #' @param ausdruck chr-Objekt der Länge 1: Regulärer Ausdruck.
  228.   #' @param escape chr-Obejekt der Länge 1: Escapezeichen.
  229.   #' @param standard chr-Obekt der Länge 1: Entweder "literal" (Standardzeichen sind die literalen Zeichen) oder "meta" (Standardzeichen sind die Metazeichen).
  230.   #' @return chr-Objekt der Länge 1: Passende sprachliche Beschreibung von {ausdruck}, abhängig von {escape} und {standard}.
  231.   #' @example beschreiben(ausdruck="ab?c", escape = "?", standard = "literal") # Regulärer Ausdruck ist"a?bc". Escapezeichen ist "?". Standardzeichen sind die literalen Zeichen.
  232.   #' @export
  233.  
  234.   i = 1
  235.   anzahl_zeichen = str_extract_all(string = ausdruck,
  236.                                    pattern = "[:print:]",
  237.                                    simplify = TRUE) %>% length()
  238.   zeichenvektor = str_extract_all(str = ausdruck,
  239.                                   pattern = "[:print:]",
  240.                                   simplify = TRUE)
  241.   zeichenfolge = ""
  242.   while (i <= anzahl_zeichen) {
  243.     if ((escape == zeichenvektor[i]) & (standard == "literal")) {
  244.       zeichenfolge <- paste0(zeichenfolge,
  245.                              "Metazeichen ",
  246.                              zeichenvektor[i + 1],
  247.                              ". "
  248.                              )
  249.       i = i + 2
  250.     } else if ((escape == zeichenvektor[i]) & (standard == "meta")) {
  251.       zeichenfolge <- paste0(zeichenfolge,
  252.                              "Literales Zeichen ",
  253.                              zeichenvektor[i + 1],
  254.                              ". ")
  255.       i = i + 2
  256.     } else if ((escape != zeichenvektor[i]) & (standard == "literal")) {
  257.       zeichenfolge <- paste0(zeichenfolge,
  258.                              "Literales Zeichen ",
  259.                              zeichenvektor[i],
  260.                              ". ")
  261.       i = i + 1
  262.     } else if ((escape != zeichenvektor[i]) & (standard == "meta")) {
  263.       zeichenfolge <- paste0(zeichenfolge,
  264.                              "Metazeichen ",
  265.                              zeichenvektor[i],
  266.                              ". ")
  267.       i = i + 1
  268.     } else {
  269.       zeichenfolge = NA
  270.       break
  271.     }
  272.  
  273.   }
  274.      zeichenfolge %>% return() # zuvor erzeugte Beschreibung als Funktionswert zurückgeben
  275. }
  276.  
  277. #' **Lösungen überprüfen -->  Aufgabe 8:**
  278. beschreiben(ausdruck = "A,BCD,E,FG,,H",
  279.             escape = ",",
  280.             standard = "literal")
  281.  
  282.  
  283. #' **Lösungen überprüfen -->  Aufgabe 9:**
  284. beschreiben(ausdruck = "hello, world",
  285.             escape = ",",
  286.             standard = "meta")
  287.  
  288. #' **Lösungen überprüfen --> Aufgabe 10:**
  289. beschreiben(ausdruck = "Haus",
  290.             escape = "a",
  291.             standard = "literal")
  292.  
  293. #' **Lösungen überprüfen --> Aufgabe 11:**
  294. beschreiben(ausdruck = "Haaus",
  295.             escape = "a",
  296.             standard = "literal")
  297. #' **Lösung überprüfen --> Aufgabe 12:**
  298. beschreiben(ausdruck = "Haaus",
  299.             escape = "a",
  300.             standard = "meta")
  301.  
  302. #' ------------------------
  303. #' ------------------------
  304.  
  305. #' **Für Bearbeitung herangezogene Anleitungen::**  
  306. #'
  307. #' Debianforum.de - Benutzer Meillo. (2022, 9. April). RegExp-Kurs 02: Metazeichen & Escaping, debianforum.de. Zugriff am 12.04.2022. Verfügbar unter: https://debianforum.de/forum/viewtopic.php?p=1299654#p1299654  
  308. #'
  309. #' Gruber, W. (2019). _Bedingungen und Schleifen_, Einführung in RStudio. Zugriff am 12.01.2022. Verfügbar unter: https://wgruber.github.io/R-Intro/bedingungen-und-schleifen.html  
  310. #'
  311. #' Kurkiewicz, D. (2017). _Introduction to docstring_. Zugriff am 12.04.2022. Verfügbar unter: https://cran.r-project.org/web/packages/docstring/vignettes/docstring_intro.html  
  312. #'
  313. #' Luhmann, M. (2015). _R für Einsteiger. Einführung in die Statistiksoftware für die Sozialwissenschaften; mit Online-Material_ (4., vollständig überarb. und erweiterte Aufl.). Weinheim, Basel: Beltz.  
  314. #'
  315. #' Riepl, W. (2020, 28. März). _Hilfe erstellen für Funktionen in eigenen R-Paketen (roxygen2)_, Statistik Dresden. Zugriff am 12.04.2022. Verfügbar unter: https://statistik-dresden.de/archives/16054  
  316. #'  
  317. #' Wickham, H. (2022, 23. Januar). _Regular expressions_, stringr.tidyverse.org. Zugriff am 12.04.2022. Verfügbar unter: https://stringr.tidyverse.org/articles/regular-expressions.html  
  318. #'
  319. #' Xie, Y., Dervieux, C. & Riederer, E. (2022). _3.3 Render an R script to a report | R Markdown Cookbook_. Zugriff am 12.04.2022. Verfügbar unter: https://bookdown.org/yihui/rmarkdown-cookbook/spin.html

Quellcode

Hier kannst du den Code kopieren und ihn in deinen bevorzugten Editor einfügen. PASTEBIN_DOWNLOAD_SNIPPET_EXPLAIN

Verlinken

URL: alles markieren
https://nopaste.debianforum.de/41636

BBCode: alles markieren
[NP]41636[/NP]

LATEST_SNIPPETS