<jupyter_start><jupyter_text>Tag 1. Kapitel 6. R Programmierung Lektion 32. Einführung zu FunktionenDiese Lektion wird aus Erklärungen dazu bestehen, was Funktionen in R sind und wie sie erstellt werden. Diese sind wichtig, da sie einer der Hauptbestandteile unserer weiteren Arbeit mit Problemstellungen in R sein werden.Was ist also eine Funktion?Formell gesehen ist eine Funktion ein nützliches Hilfsmittel, dass eine Gruppe von Anweisungen zusammenfasst, damit sie mehr als einmal ausgeführt werden müssen.Auf einem grundsätzlicheren Level erlauben uns Funktionen nicht ständig den selben Code schreiben zu müssen. Wenn ihr zurückdenkt an die Lektionen zu Strings und Listen, dann stellen wir fest, dass beispielsweise `length()` so eine Funktion ist. Da es eine häufige Aufgabe ist, die Länge einer Sequenz zu überprüfen, wäre das ein Anwendugnsfall, für den man eine Funktion schreiben würde. Funktionen sind eine der einfachsten Wege, um Code in R wiederzuverwenden. Darüber hinaus erlauben sie es uns Programmdesign besser zu verstehen.Wir kennen bereits einige eingebaute Funktionen und können über die `help` Funktion mehr über diese und ihre *Parameter* (auch Argumente genannt) erfahren:<jupyter_code>help(sum)<jupyter_output><empty_output><jupyter_text>Dabei fällt folgendes Format auf:    name_der_funktion(input1,input2,....)    Können wir das so auch selbst erstellen? Die Syntax dazu lautet wie folgt:    name_der_funktion <- function(param1,param2,...){                    Code der ausgeführt wird    }    Schauen wir uns einige Beispiele an: Beispiel 1<jupyter_code># Einfache Funktion, keine Eingabe (en. input)
hallo <- function(){
    print('Hallo!')
}
hallo()<jupyter_output>[1] "Hallo!"<jupyter_text>Beispiel 2<jupyter_code>hallodu <- function(name){
    print(paste('Hallo',name))
}

h2 <- function(name){
    print(paste('Hallo',name))
}
hallodu('Angela!')

h2("Ruben!")<jupyter_output>[1] "<NAME>!"
[1] "Hal<NAME>!"<jupyter_text>Beispiel 3<jupyter_code>add_num <- function(num1, num2){
    print(num1+num2)
}
add_num(5,10)<jupyter_output>[1] 15<jupyter_text>StandardwerteBisher mussten wir jeden einzelnen Parameter an die Funktion übergeben, wenn wir sie ausführen wollten. Es gibt allerdings auch die Möglichkeit Standardwerte zu definieren, die immer dann genutzt werden, wenn der Nutzer keine Parameter selbst definiert. Diese definierne wir durch Verwendung eines **=**:<jupyter_code>adresse <- function(name='Unbekannt'){
    print(paste('Adresse von ',name))
}
# Standard nutzen
adresse()
# Selbst definieren
adresse('Sammy')<jupyter_output>[1] "Adresse von  Sammy"<jupyter_text>Wir werden viele eingebaute Funktionen sehen, die Standardwerte für eine große Vielfalt von Aufgaben verwenden, bei denen der Nutzer typischerweise einen ganz bestimmten Wert braucht. Werte zurückgeben (en. return)Bisher habenb wir Ergebnisse nur per `print` ausgegeben. Es kann allerdings auch der Fall sein, dass wir einen Wert zurückgeben (en. return) möchten, sodass wir ihn einer Variable zuweisen können. Dazu verwenden wir das `return` Keyword:<jupyter_code>formal <- function(name='Sam',title='Herr'){
    return(paste(title,name))
}
formal()
formal('Issac','Newton')
formal('John')
formal(title='Mr.',name='Udo')
s1 <- formal('Udo','Herr')
s1
cars <- function(maxrow) {
    return(mtcars[maxrow,])
}
c <- cars(10)
c<jupyter_output><empty_output><jupyter_text>Achtet darauf, dass wir hier keine print-Ausgabe erzeugen. Wir können unser Ergebnis einer Variablen zuweisen:<jupyter_code>var <- formal('<NAME>','Frau')
var<jupyter_output><empty_output><jupyter_text>Das ist die Art von Syntax, die wir für unsere Funktionen verwenden werden: Die Übergabe von Parametern und die Rückgabe eines Ergebnisses. GeltungsbereichGeltungsbereich (en. scope) ist der Begriff, den wir dafür verwenden, um zu beschreiben wie Objekte und Variablen definiert sind. Ist eine Variable bspw. nur innerhalb einer Funktion definiert, dann sagen wir, dass ihr Geltungsbereich auf die Funktion limitiert ist.<jupyter_code>gResult <- 11
gResult
mal5_bad <- function(eingabe) {
  print('Prior')
  print(gResult)
  lResult <- eingabe * 5
    
  print('Posteriors')
  print(gResult)
  print(lResult)
  return(lResult)
}
mal5_bad(10)
gResult
# Eingabe mit 5 multiplizieren
mal5 <- function(eingabe) {
  ergebnis <- eingabe * 5
  return(ergebnis)
}
input <- 4
mal5(input)
#ergebnis # Außerhalb der Funktion nicht definiert
#eingabe # Außerhalb der Funktion nicht definiert
input<jupyter_output><empty_output><jupyter_text>Dieser Error zeigt uns an, dass die Variablen nur innerhalb des "Geltungsbereichs" der Funktion definiert sind. Varaiblen hingegen, die außerhalb der Funktion definiert werden, sind *globale* Variablen. Die Funktion kann deshalb auf sie zugreifen. Ein Beispiel:<jupyter_code>v <- "Ich bin ein globales v"
etwas <- "Auch ich bin etwas globales"

fun <- function(etwas){
    print(v) 
    etwas <- 'Etwas neues zuweisen'
    print(etwas)
}
print(v) # print v
print(etwas) #print etwas
fun(etwas) # etwas an die Funktion übergeben
# Die Neuzuweisung geschieht nur innerhalb der Funktion
print(etwas)<jupyter_output>[1] "Ich bin ein globales v"
[1] "Auch ich bin etwas globales"
[1] "Ich bin ein globales v"
[1] "Etwas neues zuweisen"
[1] "Auch ich bin etwas globales"<jupyter_text>Was passiert hier im Details? Das folgende:**print(v)** überprüft die globale Variable *v*, äußerer Geltungsbereich**print(etwas)** überprüft auch die globale Variable *etwas***fun(etwas)** wird einen Parameter akzeptieren, print auf *v* anwenden, dann *etwas* neu zuweisen (innerhalb des Geltungsbereichs der Funktion) und print auf *etwas* anwenden. Achtet dabei auf zwei Dinge:* Die Neuzuweisungvon *etwas* findet nur innerhalb der Funktion statt* Die fun Funktion überprüft zuerst, ob *v* innerhalb des Geltungsbereichs der Funktion definiert wurde. Sofern das nicht der Fall ist (wie in unserem Beispiel) wird danach der globale Geltungsbereich überprüft.Schaut euch die nachfolgende Funktion an und versichert euch, dass ihr sie versteht:<jupyter_code>doppelt <- function(a) {
  a <- 2*a
  a
}
var <- 5
doppelt(var)
var<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0886899918633035, 'fraction_numerical': 0.008136696501220505, 'mean_word_length': 5.791160220994475, 'pattern_counts': {'":': 0, '<': 63, '<?xml version=': 0, '>': 39, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '177072', 'license': 'MIT', 'n_tokens_mistral': 2206, 'n_tokens_neox': 2167, 'n_words': 685, 'path': '1.6 R Programming/de-DE/1.6.32 R - Functions.ipynb', 'repo_name': 'softfactories/r_train_2', 'size': '6158'}