IO fertig, trick mit module name in first julia cell
This commit is contained in:
parent
fb58c51aa2
commit
8e83a18cd0
13
.vscode/settings.json
vendored
13
.vscode/settings.json
vendored
@ -1,14 +1,15 @@
|
||||
{
|
||||
"julia.environmentPath": "/home/hellmund/Julia/23",
|
||||
"files.exclude": {
|
||||
"**/.git": true,
|
||||
"**/.svn": true,
|
||||
"**/.hg": true,
|
||||
"**/CVS": true,
|
||||
"**/.DS_Store": true,
|
||||
"**/Thumbs.db": true,
|
||||
"**/.git": true,
|
||||
"**/.hg": true,
|
||||
"**/.svn": true,
|
||||
"**/*.ipynb": true,
|
||||
"**/*.md": true
|
||||
"**/*.md": true,
|
||||
"**/*.quarto_ipynb": true,
|
||||
"**/CVS": true,
|
||||
"**/Thumbs.db": true
|
||||
},
|
||||
"explorerExclude.backup": {},
|
||||
"ltex.enabled": false,
|
||||
|
||||
@ -7,6 +7,8 @@ engine: julia
|
||||
#| echo: false
|
||||
#| output: false
|
||||
using InteractiveUtils
|
||||
import QuartoNotebookWorker
|
||||
Base.stdout = QuartoNotebookWorker.with_context(stdout)
|
||||
```
|
||||
|
||||
# Zeichen, Strings und Unicode
|
||||
@ -140,10 +142,6 @@ Alternativ können Sie die PDF-Version dieser Seite verwenden. Dort sind alle Fo
|
||||
|
||||
Eine kleine Hilfsfunktion:
|
||||
```{julia}
|
||||
"""
|
||||
printuc(c, n):
|
||||
print n characters from unicode table, starting with character c
|
||||
"""
|
||||
function printuc(c, n)
|
||||
for i in 0:n-1
|
||||
print(c + i)
|
||||
|
||||
@ -2,124 +2,172 @@
|
||||
engine: julia
|
||||
---
|
||||
|
||||
# Ein- und Ausgabe
|
||||
|
||||
|
||||
```{julia}
|
||||
#| error: false
|
||||
#| echo: false
|
||||
#| output: false
|
||||
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L516-L520
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L3073-L3077
|
||||
|
||||
|
||||
using InteractiveUtils
|
||||
import QuartoNotebookWorker
|
||||
Base.stdout = QuartoNotebookWorker.with_context(stdout)
|
||||
myactive_module() = Main.Notebook
|
||||
Base.active_module() = myactive_module()
|
||||
```
|
||||
|
||||
|
||||
|
||||
# Ein- und Ausgabe
|
||||
|
||||
|
||||
|
||||
zahlreiche Varianten und Funktionen, das Folgende ist eine kleine Auswahl
|
||||
|
||||
## Konsole
|
||||
|
||||
- OS-abhängig; üblicherweise 3 Kanäle _(streams)_: `stdin, stdout, stderr` (Standardinput, -output, -errorkanal)
|
||||
Das Betriebssystem stellt für ein Programm üblicherweise 3 Kanäle _(streams)_ zur Verfügung:
|
||||
|
||||
- Standardeingabekanal `stdin`
|
||||
- Standardausgabekanal `stdout` und
|
||||
- Standardfehlerausgabekanal `stderr`.
|
||||
|
||||
Wenn das Programm in einem Terminal (oder Konsole bzw. Shell) gestartet wird, kann das Programm über `stdin` die Tastatureingaben
|
||||
einlesen und Ausgaben über `stdout` sowie `stdout` erscheinen im Terminal.
|
||||
|
||||
|
||||
- Schreiben nach `stdout`: `print()`,`println()`,`printstyled()`
|
||||
- Schreiben nach `stderr`: `print(strerr,...)`, `println(stderr,...)`, `printstyled(stderr,...)`
|
||||
- Lesen von `stdin`: `readline()`
|
||||
|
||||
### Umwandeln von Strings in andere Typen:
|
||||
|
||||
- `chomp()` entfernt newline
|
||||
- `split()` zerlegt in "Wörter"
|
||||
- `parse()` wandelt in andere Typen um
|
||||
|
||||
### Buffer
|
||||
### Eingaben
|
||||
|
||||
- `write`-Zugriffe werden gebuffert.
|
||||
|
||||
- `flush(stdout)` leert Buffer
|
||||
Die Sprache _Python_ stellt eine Funktion `input()` zur Verfügung:
|
||||
```{.python}
|
||||
ans = input("Bitte eine positive Zahl eingeben!")
|
||||
```
|
||||
Die Funktion gibt den Prompt aus, wartet auf eine Eingabe und liefert die
|
||||
Eingabe als `string` zurück.
|
||||
|
||||
|
||||
In Julia kann man diese Funktion so implementieren:
|
||||
|
||||
```{julia}
|
||||
|
||||
function input(prompt = "Eingabe:")
|
||||
println(prompt)
|
||||
flush(stdout)
|
||||
return chomp(readline())
|
||||
end
|
||||
|
||||
```
|
||||
|
||||
**Anmerkungen**
|
||||
|
||||
- Schreibanweisungen werden von modernen Betriebssystemen gebuffert. Mit `flush(stdout)` wird die Leerung des Buffers und sofortige Schreiboperation erzwungen.
|
||||
- `readline()` liefert einen String zurück, der mit einer Newline `\n` endet. Die Funktion `chomp()` entfernt einen eventuellen Zeilenumbruch vom Ende eines Strings.
|
||||
|
||||
```{julia}
|
||||
#| eval: false
|
||||
a = input("Bitte 2 Zahlen eingeben!")
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
#| echo: false
|
||||
a = "34 56"
|
||||
```
|
||||
|
||||
|
||||
### Verarbeitung der Eingabe
|
||||
|
||||
> `split(str)` zerlegt einen String in "Wörter" und liefert einen _(array of strings)_:
|
||||
|
||||
```{julia}
|
||||
av = split(a)
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
parse.(Int, av)
|
||||
```
|
||||
> `parse(T, str)` versucht, `str` in den Typ `T` umzuwandeln:
|
||||
|
||||
|
||||
```{julia}
|
||||
# Ausgaben auf den Fehlerkanal stderr erscheinen im Jupyter in rot:
|
||||
@warn "Das @warn-Macro schreibt nach stderr."
|
||||
println("Hallo!")
|
||||
println(stderr, "Das sollte nicht passieren!")
|
||||
v = parse.(Int, av)
|
||||
```
|
||||
|
||||
`parse()` erzeugt einen Fehler, wenn der String sich nicht als Wertangabe von Typ `T` parsen lässt. Man kann den Fehler mit
|
||||
`try/catch` abfangen oder die Funktion `tryparse(T, str)` verwenden, die in so einem Fall `nothing` zurückgibt - worauf man dann
|
||||
z.B. mit `isnothing()` testen kann.
|
||||
|
||||
|
||||
|
||||
### Einzelne Tastenanschläge einlesen
|
||||
|
||||
- `readline()` u.ä. warten auf den Abschluss der Eingabe durch Drücken der `Enter`-Taste.
|
||||
- Zum Einlesen einzelner _keystrokes_:
|
||||
- Techniken zum Einlesen einzelner _keystrokes_ findet man hier:
|
||||
|
||||
- [https://stackoverflow.com/questions/56888266/how-to-read-keyboard-inputs-at-every-keystroke-in-julia](https://stackoverflow.com/questions/56888266/how-to-read-keyboard-inputs-at-every-keystroke-in-julia)
|
||||
- [https://stackoverflow.com/questions/60954235/how-can-i-test-whether-stdin-has-input-available-in-julia](https://stackoverflow.com/questions/60954235/how-can-i-test-whether-stdin-has-input-available-in-julia)
|
||||
|
||||
|
||||
## Formatierte Ausgabe mit dem `Printf`-Paket
|
||||
|
||||
Die Macros `@sprintf` und `@printf` sind den gleichnamigen C-Funktionen nachempfunden
|
||||
|
||||
- Formatstring: Normaler String mit Platzhaltern
|
||||
- Platzhalter haben die Form
|
||||
## Formatierte Ausgabe mit dem `Printf`-Makro
|
||||
|
||||
Oft möchte man Zahlen oder Strings mit einer strikten Formatvorgabe - Gesamtlänge, Nachkommastellen, rechts/linksbündig usw - ausgeben.
|
||||
|
||||
Dazu definiert das Paket `Printf` die Makros `@sprintf` und `@printf`, welche sehr ähnlich wie die gleichnamigen C-Funktionen arbeiten.
|
||||
|
||||
```{julia}
|
||||
using Printf
|
||||
|
||||
x = 123.7876355638734
|
||||
|
||||
@printf("Ausgabe rechtsbündig mit max. 10 Zeichen Platz und 3 Nachkommastellen: x= %10.3f", x)
|
||||
```
|
||||
|
||||
|
||||
Das erste Argument ist ein String, der Platzhalter (hier: `%10.3`) für auszugebende Variablen enthält; gefolgt von diesen Variablen als weitere Argumente.
|
||||
|
||||
Platzhalter haben die Form
|
||||
```
|
||||
%[flags][width][.precision]type
|
||||
```
|
||||
(wobei die Angaben in eckigen Klammern alle optional sind)
|
||||
- Typen:
|
||||
```
|
||||
%s string
|
||||
%i integer
|
||||
%o integer octal (base=8)
|
||||
%x, %X integer hexadecimal (base=16) with digits 0-9abcdef or 0-9ABCDEF, resp.
|
||||
%f floatong point number
|
||||
%e floating point number, scientific representation
|
||||
%g floating point, uses %f or %e depending on value
|
||||
```
|
||||
wobei die Angaben in eckigen Klammern alle optional sind.
|
||||
|
||||
- Flags:
|
||||
```
|
||||
Pluszeichen: rechtsbündig (Standard)
|
||||
Minuszeichen: linksbündig
|
||||
Null: mit führenden Nullen
|
||||
```
|
||||
**Typangaben im Platzhalter**
|
||||
|
||||
| | |
|
||||
|:--|:------------|
|
||||
|`%s`| `string`|
|
||||
|`%i`| `integer`|
|
||||
|`%o`| `integer octal (base=8)`|
|
||||
|`%x, %X`| `integer hexadecimal (base=16) with digits 0-9abcdef or 0-9ABCDEF, resp.`|
|
||||
|`%f`| `floating point number`|
|
||||
|`%e`| `floating point number, scientific representation`|
|
||||
|`%g`| `floating point, uses %f or %e depending on value`|
|
||||
|
||||
: {.striped .hover}
|
||||
|
||||
|
||||
**Flags**
|
||||
|
||||
| | |
|
||||
|:----|:-----|
|
||||
|Pluszeichen| rechtsbündig (Standard)|
|
||||
|Minuszeichen| linksbündig|
|
||||
|Null| mit führenden Nullen|
|
||||
|
||||
: {.striped .hover}
|
||||
|
||||
|
||||
**Width**
|
||||
|
||||
- Width:
|
||||
```
|
||||
Anzahl der minimal verwendeten Zeichen (wenn nötig, werden auch mehr genommen)
|
||||
```
|
||||
|
||||
|
||||
Zeit für Beispiele:
|
||||
### Beispiele:
|
||||
|
||||
|
||||
```{julia}
|
||||
@ -130,6 +178,7 @@ using Printf # Paket laden nicht vergessen!
|
||||
```{julia}
|
||||
@printf("|%s|", "Hallo") # string mit Platzhalter für String
|
||||
```
|
||||
Die senkrechten Striche sind nicht Teil des Platzhalters. Sie sollen die Begrenzung des Ausgabefeldes anzeigen.
|
||||
|
||||
|
||||
```{julia}
|
||||
@ -144,7 +193,7 @@ using Printf # Paket laden nicht vergessen!
|
||||
|
||||
```{julia}
|
||||
@printf("|%3s|", "Hallo") # Längenangabe kann überschritten werden
|
||||
# besser eine 'kaputt formatierte' Tabelle als falsche Werte!!
|
||||
# besser eine 'kaputt formatierte' Tabelle als falsche Werte!
|
||||
```
|
||||
|
||||
|
||||
@ -156,21 +205,21 @@ l = 3342678
|
||||
@printf("j= %012i, k= %-12i, l = %12i", j, k, l) # 0-Flag für führende Nullen
|
||||
```
|
||||
|
||||
`@printf` und `@sprintf` können wie alle Macros wie Funktionen aufgerufen werden:
|
||||
`@printf` und `@sprintf` können wie alle Makros wie Funktionen aufgerufen werden:
|
||||
|
||||
|
||||
```{julia}
|
||||
@printf("%i %i", 22, j)
|
||||
```
|
||||
|
||||
-- oder wie Macros, also ohne Funktionsklammern und ohne Komma:
|
||||
-- oder wie Makros, also ohne Funktionsklammern und ohne Komma:
|
||||
|
||||
|
||||
```{julia}
|
||||
@printf "%i %i" 22 j
|
||||
```
|
||||
|
||||
`@printf` kann als erstes Argument noch einen stream übergeben bekommen.
|
||||
`@printf` kann als erstes Argument noch einen Stream übergeben bekommen.
|
||||
|
||||
Ansonsten besteht die Argumentliste aus
|
||||
|
||||
@ -183,7 +232,7 @@ Ansonsten besteht die Argumentliste aus
|
||||
j, "(geschätzt)" ,k)
|
||||
```
|
||||
|
||||
`@sprintf` druckt nichts, sondern liefert den ausgefüllten formatierten String zurück:
|
||||
Das Makro `@sprintf` druckt nichts, sondern liefert den ausgefüllten formatierten String zurück:
|
||||
|
||||
|
||||
```{julia}
|
||||
@ -195,12 +244,12 @@ str = @sprintf("x = %10.6f", π );
|
||||
str
|
||||
```
|
||||
|
||||
##### Formatierung der Gleitkommazahlen:
|
||||
### Formatierung der Gleitkommazahlen:
|
||||
|
||||
Bedeutung des _Precision_-Wertes:
|
||||
|
||||
- `%f` und `%e`-Format: max. Anzahl der Nachkommastellen
|
||||
- `%g`-Format: max. Anzahl von ausgegebenen Ziffern (Vor- + Nachkommastellen)
|
||||
- `%f` und `%e`-Format: maximale Anzahl der Nachkommastellen
|
||||
- `%g`-Format: maximale Anzahl von ausgegebenen Ziffern (Vor- + Nachkommastellen)
|
||||
|
||||
|
||||
```{julia}
|
||||
@ -223,157 +272,153 @@ x = 123456.7890123456
|
||||
|
||||
Dateien werden
|
||||
|
||||
- geöffnet ==> Dabei ensteht ein neues _stream_-Objekt (zusätzlich zu `stdin, stdout, stderr`)
|
||||
- geöffnet $\Longrightarrow$ dabei ensteht ein neues _stream_-Objekt (zusätzlich zu `stdin, stdout, stderr`)
|
||||
- dann kann dieser _stream_ gelesen und geschrieben werden
|
||||
- geschlossen ==> _stream_-Objekt wird von Datei getrennt
|
||||
- geschlossen $\Longrightarrow$ _stream_-Objekt wird von Datei getrennt
|
||||
|
||||
```
|
||||
```{.julia}
|
||||
stream = open(path, mode)
|
||||
```
|
||||
|
||||
- path: Dateiname/pfad
|
||||
- mode:
|
||||
|
||||
```
|
||||
"r" read, öffnet am Dateianfang
|
||||
"w" write, öffnet am Dateianfang (Datei wird neu angelegt oder überschrieben)
|
||||
"a" append, öffnet zum Weiterschreiben am Dateiende
|
||||
```
|
||||
|
||||
Schreiben wir mal eine Datei:
|
||||
|
||||
```{julia}
|
||||
f = open("datei.txt", "w")
|
||||
```
|
||||
|
||||
|
||||
```julia
|
||||
@printf(f, "%20i\n", k)
|
||||
file = open("datei.txt", "w")
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
println(f, " zweite Zeile")
|
||||
@printf(file, "%10i\n", k)
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
close(f)
|
||||
println(file, " zweite Zeile")
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
close(file)
|
||||
```
|
||||
|
||||
Schauen wir uns die Datei an:
|
||||
|
||||
```{julia}
|
||||
;cat datei.txt
|
||||
```
|
||||
|
||||
...und jetzt öffnen wir sie wieder zum Einlesen:
|
||||
|
||||
```{julia}
|
||||
f = open("datei.txt", "r")
|
||||
stream = open("datei.txt", "r")
|
||||
```
|
||||
|
||||
`readlines(stream)` liefert alle Zeilen einer Textdatei als Vector von Strings.
|
||||
|
||||
`eachline(stream)` liefert einen Iterator über die Zeilen der Datei.
|
||||
|
||||
|
||||
```{julia}
|
||||
n = 0
|
||||
for i in readlines(f) # Lese zeilenweise
|
||||
for line in eachline(stream) # Lese zeilenweise
|
||||
n += 1
|
||||
println(n, i) # Drucke mit Zeilennummer
|
||||
println(n, line) # Drucke mit Zeilennummer
|
||||
end
|
||||
close(stream)
|
||||
```
|
||||
|
||||
## Pakete für Dateiformate
|
||||
|
||||
Pakete für die Ein- und Ausgabe in den verschiedensten Dateiformaten
|
||||
Für die Ein- und Ausgabe in den verschiedensten Dateiformaten existieren Julia-Pakete, z.B.
|
||||
|
||||
- [PrettyTables.jl](https://ronisbr.github.io/PrettyTables.jl/stable/) Ausgabe von formatierten Tabellen
|
||||
- [DelimitedFiles.jl](https://docs.julialang.org/en/v1/stdlib/DelimitedFiles/) Ein- und Ausgabe von Matrizen u.ä.
|
||||
- [CSV.jl](https://csv.juliadata.org/stable/) Ein- und Ausgabe von Dateien mit "comma-delimited values" u.ä.
|
||||
- [CSV.jl](https://csv.juliadata.org/stable/) Ein- und Ausgabe von Dateien mit "comma-separated values" u.ä.
|
||||
- [XLSX.jl](https://felipenoris.github.io/XLSX.jl/stable/tutorial/) Ein- und Ausgabe von Excel-Dateien
|
||||
|
||||
und viele andere mehr...
|
||||
|
||||
### Delimited Files
|
||||
|
||||
### DelimitedFiles.jl
|
||||
|
||||
Dieses Paket ermöglicht das bequeme Abspeichern/Einlesen von Matrizen. Dazu stellt es die Funktionen `writedlm()` und `readdlm()` zur
|
||||
Verfügung.
|
||||
|
||||
```{julia}
|
||||
using DelimitedFiles
|
||||
```
|
||||
|
||||
|
||||
Wir erzeugen eine 200×3-Matrix von Zufallszahlen
|
||||
```{julia}
|
||||
A = rand(200,3)
|
||||
```
|
||||
|
||||
|
||||
und speichern diese
|
||||
```{julia}
|
||||
f = open("data2.txt", "w")
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
writedlm(f, A)
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
close(f)
|
||||
```
|
||||
|
||||
|
||||
Die geschriebene Datei fängt so an:
|
||||
|
||||
```{julia}
|
||||
;head data2.txt
|
||||
```
|
||||
|
||||
|
||||
Das Wiedereinlesen ist noch einfacher:
|
||||
```{julia}
|
||||
B = readdlm("data2.txt")
|
||||
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
# man kann open() auch als 1.Argument eine function(iostream) übergeben, die auf den stream
|
||||
# angewendet wird, wonach der stream automatisch geschlosssen wird.
|
||||
#
|
||||
# Mit der do-Notation sieht obiger code so aus:
|
||||
Noch ein Punkt: Beim Umgang mit Dateien wird in Julia oft die `do`-Notation verwendet, s. @sec-do.
|
||||
Dazu nutzt man, dass `open()` auch Methoden hat, bei denen das 1. Argument eine `function(iostream)` ist.
|
||||
Diese wird dann auf den _stream_ angewendet und dieser abschliessend automatisch geschlossen. Die `do`-Notation erlaubt es,
|
||||
diese Funktion anonym nach dem `do` zu definieren:
|
||||
|
||||
```{julia}
|
||||
open("data2.txt", "w") do io
|
||||
writedlm(io, A)
|
||||
end
|
||||
|
||||
```
|
||||
|
||||
### CSV und DataFrames
|
||||
|
||||
- [DataFrames.jl](https://dataframes.juliadata.org/stable/) ist ein Paket zum bequemen Umgang mit tabellarischen Daten
|
||||
|
||||
- Das CSV-Format wird oft benutzt, um Tabellen in einer nicht nur mit MS Excel lesbaren Form zur Verfügung zu stellen.
|
||||
- Ein Beispiel ist die Wetter- und Klimadatenbank _Meteostat_.
|
||||
- Das Paket [DataFrames.jl](https://dataframes.juliadata.org/stable/) stellt Funktionen zum bequemen Umgang mit tabellarischen Daten
|
||||
zur Verfügung.
|
||||
|
||||
|
||||
|
||||
```{julia}
|
||||
using CSV, DataFrames, Downloads
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
# Wetterdaten von Westerland, s. https://dev.meteostat.net/bulk/hourly.html
|
||||
|
||||
|
||||
url = "https://bulk.meteostat.net/v2/hourly/10018.csv.gz"
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
http_response = Downloads.download(url)
|
||||
file = CSV.File(http_response, header=false);
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
file = CSV.File(http_response, header=false)
|
||||
```
|
||||
Die Daten sehen so aus:
|
||||
|
||||
|
||||
```{julia}
|
||||
# https://dev.meteostat.net/bulk/hourly.html#endpoints
|
||||
|
||||
#
|
||||
# Spalte 1 Datum
|
||||
# 2 Uhrzeit (Stunde)
|
||||
# 3 Temp
|
||||
@ -382,25 +427,30 @@ file = CSV.File(http_response, header=false)
|
||||
# 8 Windrichtung
|
||||
# 9 Windstärke
|
||||
|
||||
|
||||
df = DataFrame(file)
|
||||
```
|
||||
|
||||
|
||||
|
||||
```{julia}
|
||||
#| error: false
|
||||
#| echo: false
|
||||
#| output: false
|
||||
#| eval: false
|
||||
describe(df)
|
||||
```
|
||||
|
||||
|
||||
|
||||
Zum bequemen Plotten und zum Umgang mit den Datums- und Zeitformaten in der Wettertabelle
|
||||
laden wir noch 2 Helferlein:
|
||||
|
||||
```{julia}
|
||||
using StatsPlots
|
||||
using StatsPlots, Dates
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
using Dates
|
||||
```
|
||||
|
||||
Wir erzeugen eine neue Spalte, die Datum (asu Spalte 1) und Uhrzeit (aus Spalte 2) kombiniert:
|
||||
|
||||
```{julia}
|
||||
# neue Spalte mit Sp.1 und 2 (date & time) kombiniert
|
||||
@ -409,20 +459,24 @@ df[!, :datetime] = DateTime.(df.Column1) .+ Hour.(df.Column2);
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
describe(df)
|
||||
```
|
||||
|
||||
|
||||
```{julia}
|
||||
#| error: false
|
||||
#| echo: false
|
||||
#| output: false
|
||||
#| eval: false
|
||||
|
||||
@df df plot(:datetime, :Column3)
|
||||
```
|
||||
|
||||
Und nun zum Plot:
|
||||
|
||||
```{julia}
|
||||
@df df plot(:datetime, [:Column9, :Column6, :Column3],
|
||||
xlims = (DateTime(2022,1,1), DateTime(2022,7,1)),
|
||||
layout=(3,1), title=["Wind" "Regen" "Temp"], legend=:none)
|
||||
xlims = (DateTime(2023,9,1), DateTime(2024,5,30)),
|
||||
layout=(3,1), title=["Wind" "Regen" "Temp"],
|
||||
legend=:none, size=(800,800))
|
||||
```
|
||||
|
||||
|
||||
|
||||
@ -9,6 +9,12 @@ engine: julia
|
||||
#| echo: false
|
||||
#| output: false
|
||||
using InteractiveUtils
|
||||
import QuartoNotebookWorker
|
||||
Base.stdout = QuartoNotebookWorker.with_context(stdout)
|
||||
myactive_module() = Main.Notebook
|
||||
Base.active_module() = myactive_module()
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L516-L520
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L3073-L3077
|
||||
```
|
||||
|
||||
## Dokumentation
|
||||
|
||||
@ -7,6 +7,10 @@ engine: julia
|
||||
#| echo: false
|
||||
#| output: false
|
||||
using InteractiveUtils
|
||||
import QuartoNotebookWorker
|
||||
Base.stdout = QuartoNotebookWorker.with_context(stdout)
|
||||
myactive_module() = Main.Notebook
|
||||
Base.active_module() = myactive_module()
|
||||
```
|
||||
|
||||
# Vektoren, Matrizen, Arrays
|
||||
|
||||
@ -2,14 +2,21 @@
|
||||
engine: julia
|
||||
---
|
||||
|
||||
# Funktionen und Operatoren
|
||||
|
||||
```{julia}
|
||||
#| error: false
|
||||
#| echo: false
|
||||
#| output: false
|
||||
using InteractiveUtils
|
||||
import QuartoNotebookWorker
|
||||
Base.stdout = QuartoNotebookWorker.with_context(stdout)
|
||||
myactive_module() = Main.Notebook
|
||||
Base.active_module() = myactive_module()
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L516-L520
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L3073-L3077
|
||||
```
|
||||
|
||||
# Funktionen und Operatoren
|
||||
|
||||
Funktionen verarbeiten ihre Argumente zu einem Ergebnis, das sie beim Aufruf zurückliefern.
|
||||
|
||||
@ -305,7 +312,7 @@ f(.2)
|
||||
["a", "list", "of", "strings"] .|> [length, uppercase, reverse, titlecase]
|
||||
```
|
||||
|
||||
## Die `do`-Notation
|
||||
## Die `do`-Notation {#sec-do}
|
||||
|
||||
Eine syntaktische Besonderheit zur Definition anonymer Funktionen als Argumente anderer Funktionen ist die `do`-Notation.
|
||||
|
||||
|
||||
@ -2,11 +2,19 @@
|
||||
engine: julia
|
||||
---
|
||||
|
||||
# Ein Fallbeispiel: Der parametrisierte Datentyp PComplex
|
||||
|
||||
```{julia}
|
||||
#| error: false
|
||||
#| echo: false
|
||||
#| output: false
|
||||
using InteractiveUtils
|
||||
import QuartoNotebookWorker
|
||||
Base.stdout = QuartoNotebookWorker.with_context(stdout)
|
||||
myactive_module() = Main.Notebook
|
||||
Base.active_module() = myactive_module()
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L516-L520
|
||||
# https://github.com/JuliaLang/julia/blob/master/base/show.jl#L3073-L3077
|
||||
```
|
||||
|
||||
# Ein Fallbeispiel: Der parametrisierte Datentyp PComplex
|
||||
|
||||
@ -8,6 +8,10 @@ engine: julia
|
||||
#| echo: false
|
||||
#| output: false
|
||||
using InteractiveUtils
|
||||
import QuartoNotebookWorker
|
||||
Base.stdout = QuartoNotebookWorker.with_context(stdout)
|
||||
myactive_module() = Main.Notebook
|
||||
Base.active_module() = myactive_module()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user