zur Übersicht nächste Seite

read tabelle

Es wird das leicht veränderte Rechenprogramm bC von der Seite
Debian Gnome Tabelle aus PDF
verwendet.
Generell gilt bei den weißen Textstellen auf dieser Seite: Man fügt die Zeichenfolge aus dem weißen Feld bei dem blinkenden Cursor des Terminals ein - dann drückt man die Eingabetaste.
Wichtig ist auch daß der verwendete Texteditor die Eingaben Linux-codiert speichert. Bei gedit kann man mit dem Menupunkt 
Speichern unter
Einstellungen vornehmen und diese sollten so aussehen

Bei Windows-codierten txt-Dateien kann es zu Problemen kommen.


Mit dem Programm 
read
kann man Eingaben lesen. Dazu wird eine Datei in dem  Ordner ~/Bla erzeugt
gedit ~/Bla/hK.txt
Eingabe in den Editor
1:28:2:3:0:1
2:8:3:1:1:0
2:31:8:11:3:0
2:18:4:3:4:0
Dann Speichern. Danach wird aus dieser Datei eine Variable erzeugt, dazu das Terminal in ~/Bla öffnen und auch weiterhin in ~/Bla geöffnet lassen
dN=$(cat hK.txt)
read liest jeweils eine Zeile. 
Hinter dem read gibt man eine Zeichenfolge ohne LEERZEICHEN ein. Diese Zeichenfolge wird zu einer Variablen mit dem Inhalt der ersten Zeile.
read a < hK.txt

echo "a"
1:28:2:3:0:1

auch
read Zeile <<< "$dN"

echo "Zeile"
1:28:2:3:0:1

Auf der Seite Debian Gnome Programmfenster Sonderzeichen
wurden 30 Variablen definiert:

zS01=$(cat ~/.meine_sonderzeichen/zS01.txt | cut -c 1-10 | head -n 1)
zS02=$(cat ~/.meine_sonderzeichen/zS02.txt | cut -c 1-10 | head -n 1)
zS03=$(cat ~/.meine_sonderzeichen/zS03.txt | cut -c 1-10 | head -n 1)
zS04=$(cat ~/.meine_sonderzeichen/zS04.txt | cut -c 1-10 | head -n 1)
zS05=$(cat ~/.meine_sonderzeichen/zS05.txt | cut -c 1-10 | head -n 1)
zS06=$(cat ~/.meine_sonderzeichen/zS06.txt | cut -c 1-10 | head -n 1)
zS07=$(cat ~/.meine_sonderzeichen/zS07.txt | cut -c 1-10 | head -n 1)
zS08=$(cat ~/.meine_sonderzeichen/zS08.txt | cut -c 1-10 | head -n 1)
zS09=$(cat ~/.meine_sonderzeichen/zS09.txt | cut -c 1-10 | head -n 1)
zS10=$(cat ~/.meine_sonderzeichen/zS10.txt | cut -c 1-10 | head -n 1)
zS11=$(cat ~/.meine_sonderzeichen/zS11.txt | cut -c 1-10 | head -n 1)
zS12=$(cat ~/.meine_sonderzeichen/zS12.txt | cut -c 1-10 | head -n 1)
zS13=$(cat ~/.meine_sonderzeichen/zS13.txt | cut -c 1-10 | head -n 1)
zS14=$(cat ~/.meine_sonderzeichen/zS14.txt | cut -c 1-10 | head -n 1)
zS15=$(cat ~/.meine_sonderzeichen/zS15.txt | cut -c 1-10 | head -n 1)
zS16=$(cat ~/.meine_sonderzeichen/zS16.txt | cut -c 1-10 | head -n 1)
zS17=$(cat ~/.meine_sonderzeichen/zS17.txt | cut -c 1-10 | head -n 1)
zS18=$(cat ~/.meine_sonderzeichen/zS18.txt | cut -c 1-10 | head -n 1)
zS19=$(cat ~/.meine_sonderzeichen/zS19.txt | cut -c 1-10 | head -n 1)
zS20=$(cat ~/.meine_sonderzeichen/zS20.txt | cut -c 1-10 | head -n 1)
zS21=$(cat ~/.meine_sonderzeichen/zS21.txt | cut -c 1-10 | head -n 1)
zS22=$(cat ~/.meine_sonderzeichen/zS22.txt | cut -c 1-10 | head -n 1)
zS23=$(cat ~/.meine_sonderzeichen/zS23.txt | cut -c 1-10 | head -n 1)
zS24=$(cat ~/.meine_sonderzeichen/zS24.txt | cut -c 1-10 | head -n 1)
zS25=$(cat ~/.meine_sonderzeichen/zS25.txt | cut -c 1-10 | head -n 1)
zS26=$(cat ~/.meine_sonderzeichen/zS26.txt | cut -c 1-10 | head -n 1)
zS27=$(cat ~/.meine_sonderzeichen/zS27.txt | cut -c 1-10 | head -n 1)
zS28=$(cat ~/.meine_sonderzeichen/zS28.txt | cut -c 1-10 | head -n 1)
zS29=$(cat ~/.meine_sonderzeichen/zS29.txt | cut -c 1-10 | head -n 1)
zS30=$(cat ~/.meine_sonderzeichen/zS30.txt | cut -c 1-10 | head -n 1)

Dies kann man mit read so machen
for i in {01..30}; do read zS$i <<< $(cat ~/.meine_sonderzeichen/zS$i.txt | cut -c 1-10 | head -n 1); done


Nun wird es interessant: Man kann read ein Trennzeichen mit IFS vorgeben und dann trennt read die Zeile in "Worte" auf und man kann read mehrere Zeichenfolgen getrennt durch LEERZEICHEN vorgeben und diese werden als Variablen den "Worten" zugeordnet.
Das erste Wort der Eingabe wird der ersten Variablen zugewiesen, das zweite Wort der zweiten Variablen, und so weiter. Wenn mehr Variablen angegeben sind, als die Eingabe Worte enthält, dann sind die überzähligen Variablen leer. Wenn die Eingabe mehr Worte enthält, als Variablen angegeben sind, dann erhält die letzte Variable den ganzen Rest der Eingabezeile.
IFS=: read a1 a2 a3 <<< "$dN"

echo "$a3 da diese Variable den Rest aufnimmt, $a2 danach $a1"
2:3:0:1 da diese Variable den Rest aufnimmt, 28 danach 1

Auf der Seite
Debian Gnome Programmfenster verbesserte Suchfunktion
wurde aus der Variablen "$yA" drei andere Variablen erzeugt:
suchTXT=$(echo "$yA" | cut -f 1 -d '|')
suchWORD=$(echo "$yA" | cut -f 3 -d '|')
suchLIB=$(echo "$yA" | cut -f 2 -d '|')

Dies kann man mit read so machen
IFS="|" read suchTXT suchLIB suchWORD <<< "$yA"


Mit einer while-Schleife kann man noch mehr erreichen
while IFS=: read Spalte1 Spalte2 A B C Spalte6; do echo "$Spalte1 -> $Spalte6"; done <<< "$dN"
1 -> 1
2 -> 0
2 -> 0
2 -> 0

Damit lassen sich Spalten vertauschen oder mehrfach ausgeben.
while IFS=: read Spalte1 Spalte2 A B C Spalte6; do echo "$C $C $B $B"; done <<< "$dN"
0 0 3 3
1 1 1 1
3 3 11 11
4 4 3 3

Es soll eine Tabelle aus einer Tabellenkalkulation zugrundegelegt werden

Die Spalten sind beschriftet, wobei WocheN die Verkaufszahlen in der Woche N ausgibt. Bevor die Woche 1 beginnt kostet der Artikel Preis1, nach der Woche 2 (vor Beginn der Woche 3) wird der Preis2 angesetzt. Man kann die Tabellenzellen kopieren und in gedit einfügen. Der blinkende Cursor erscheint in einer neuen Zeile. Daher drückt man die Rückwärtstaste damit der blinkende Cursor hinter dem letzten Zahlenwert erscheint. Ansonsten hat man eine zusätzliche LEERZEILE, die man entfernen müßte.
Man speichert die Datei unter sa.txt im Ordner ~/Bla ab und das Terminal bleibt weiterhin in ~/Bla geöffnet.
Aufruf im Terminal.
cat sa.txt
Artikel	Preis1	Woche1	Woche2	Preis2	Woche3	Woche4	Woche5
Schraube14	0,03	552	496	0,04	603	518	584
Schraube16	0,05	168	203	0,06	119	177	187
Schraube18	0,08	28	66	0,09	53	49	33
Nagel50	0,11	173	147	0,12	166	151	92
Nagel60	0,13	455	338	0,16	382	403	411
Nagel70	0,18	98	141	0,21	107	125	86

Wenn die Werte im Terminal nicht so schön getrennt erscheinen könnte man eine optische Formatierung durchführen
cat sa.txt | column -t
Aber das ist nur Kosmetik. 

Nachweis daß das Trennzeichen ein Tabulator-Zeichen \t ist
cat sa.txt | sed 's/\t/\\t/g'

Artikel\tPreis1\tWoche1\tWoche2\tPreis2\tWoche3\tWoche4\tWoche5
Schraube14\t0,03\t552\t496\t0,04\t603\t518\t584
Schraube16\t0,05\t168\t203\t0,06\t119\t177\t187
Schraube18\t0,08\t28\t66\t0,09\t53\t49\t33
Nagel50\t0,11\t173\t147\t0,12\t166\t151\t92
Nagel60\t0,13\t455\t338\t0,16\t382\t403\t411
Nagel70\t0,18\t98\t141\t0,21\t107\t125\t86


Das Tabulatorzeichen wird von read ohne weiteres akzepiert genauso wie das LEERZEICHEN (man braucht keine IFS zu setzen) und es sollen die von read eingelesenen Variablen den Spaltenbezeichnungen aus der Tabellenkalkulation entsprechen.
Man möchte den Gesamtpreis berechnen, also kurz mit den Spalten-Bezeichnungen aus dem Tabellenprogramm (C+D)xB+(F+G+H)xE
while read A B C D E F G H; do echo "($C+$D)*$B+($F+$G+$H)*$E"; done < sa.txt
(Woche1+Woche2)*Preis1+(Woche3+Woche4+Woche5)*Preis2
(552+496)*0,03+(603+518+584)*0,04
(168+203)*0,05+(119+177+187)*0,06
(28+66)*0,08+(53+49+33)*0,09
(173+147)*0,11+(166+151+92)*0,12
(455+338)*0,13+(382+403+411)*0,16
(98+141)*0,18+(107+125+86)*0,21

Mit dem Tabellenprogramm könnte dies so aussehen

Nun kann man die erste Zeile löschen und alles an bC (Seite: Debian Gnome Tabelle aus PDF) verfüttern.
while read A B C D E F G H; do echo "($C+$D)*$B+($F+$G+$H)*$E"; done < sa.txt | sed '1d' | bC
99.64
47.53
19.67
84.28
294.45
109.80

Aber man kann auch die sa.txt mit sed einlesen und die erste Zeile löschen und dies als Variable an read übergeben. Dann kann man auch innerhalb der while-Schleife rechnen.
while read A B C D E F G H; do GS=$(echo "($C+$D)*$B+($F+$G+$H)*$E" | bC); GM=$(echo "$C+$D+$F+$G+$H" | bC); echo "$A Verkaufsmenge:$GM Gesamtbetrag:$GS - Preis wurde von $B auf $E geändert"; done <<< $(sed '1d' < sa.txt)

Schraube14 Verkaufsmenge:2753 Gesamtbetrag:99.64 - Preis wurde von 0,03 auf 0,04 geändert
Schraube16 Verkaufsmenge:854 Gesamtbetrag:47.53 - Preis wurde von 0,05 auf 0,06 geändert
Schraube18 Verkaufsmenge:229 Gesamtbetrag:19.67 - Preis wurde von 0,08 auf 0,09 geändert
Nagel50 Verkaufsmenge:729 Gesamtbetrag:84.28 - Preis wurde von 0,11 auf 0,12 geändert
Nagel60 Verkaufsmenge:1989 Gesamtbetrag:294.45 - Preis wurde von 0,13 auf 0,16 geändert
Nagel70 Verkaufsmenge:557 Gesamtbetrag:109.80 - Preis wurde von 0,18 auf 0,21 geändert


Oder auch
while read A B C D E F G H; do GS=$(echo "($C+$D)*$B+($F+$G+$H)*$E" | bC); GSS=$(echo "($C+$D+$F+$G+$H)*$B" | bC); PR=$(echo "$GS*10000/$GSS-10000" | bC | sed 's/\([0-9][0-9]\)$/,\1/'); echo "$A BAR-Verkauf:$GS ohne Preiserhöhung nur $GSS gewesen, Verkaufs-PLUS:$PR%"; done <<< $(sed '1d' < sa.txt)

Schraube14 BAR-Verkauf:99.64 ohne Preiserhöhung nur 82.59 gewesen, Verkaufs-PLUS:20,64%
Schraube16 BAR-Verkauf:47.53 ohne Preiserhöhung nur 42.70 gewesen, Verkaufs-PLUS:11,31%
Schraube18 BAR-Verkauf:19.67 ohne Preiserhöhung nur 18.32 gewesen, Verkaufs-PLUS:7,36%
Nagel50 BAR-Verkauf:84.28 ohne Preiserhöhung nur 80.19 gewesen, Verkaufs-PLUS:5,10%
Nagel60 BAR-Verkauf:294.45 ohne Preiserhöhung nur 258.57 gewesen, Verkaufs-PLUS:13,87%
Nagel70 BAR-Verkauf:109.80 ohne Preiserhöhung nur 100.26 gewesen, Verkaufs-PLUS:9,51%



Innerhalb der while-Schleife wird jeweils eine Zeile bearbeitet so daß z.B. die Variable $GM sich mit jeder Zeile verändert. Aber man kann eine NEUE Variable $GM außerhalb der while-Schleife erzeugen, die dann auch entsprechende Zeilen-Werte für alle Artikel ausgibt.
GM=$(while read A B C D E F G H; do GM=$(echo "$C+$D+$F+$G+$H" | bC); echo "$GM"; done <<< $(sed '1d' < sa.txt))

echo "$GM"
2753
854
229
729
1989
557

Genauso mit dem BAR-Verkauf
GS=$(while read A B C D E F G H; do GS=$(echo "($C+$D)*$B+($F+$G+$H)*$E" | bC); echo "$GS"; done <<< $(sed '1d' < sa.txt))

echo "$GS"
99.64
47.53
19.67
84.28
294.45
109.80

Nun kann man Spaltenbeschriftungen einfügen und die neuen Spalten und die alte Tabelle aneinanderkleben.
Vielleicht noch ein wenig Kosmetik
paste <(cat sa.txt) <(sed '1iMenge' <<< "$GM") <(sed '1iVerkauf' <<< "$GS") | column -t

Es könnte natürlich vorkommen daß in einer Woche bei einem Artikel keine Stückzahl verkauft wurde, die Tabellenzelle wäre dann leer. In einem solchen Fall ergibt der Aufruf
cat sa.txt
im Terminal an der Position der LEERZELLE zwei Tabulatorzeichen hintereinander und die Variablenzuordnung gerät durcheinander. Eine Lösung wäre es
Tabulatorzeichen Tabulatorzeichen
zu ersetzten durch
Tabulatorzeichen 0 Tabulatorzeichen
Also sed 's/\t\t/\t0\t/g'
Nun könnten aber auch mehrere LEERZELLEN hintereinander in einer Zeile vorkommen. Daher muß man das Vorgehen erweitern. Möglich wäre folgendes:
$(sed '1d' < sa.txt)
zu ersetzen durch

$(sed '1d' < sa.txt | sed '/^\t/s/^/0/' | sed '/\t$/s/$/0/' | sed 's/\t\t/\t0\t/g' | sed 's/\t\t/\t0\t/g')

Würde nun bei einem Artikel überhaupt keine Stückzahl verkauft, so wäre der Wert von $GSS NULL. Um bei der Prozentberechnung das Teilen durch 0 zu vermeiden, kann man

PR=$(echo "($GS+0,00001)*10000/($GSS+0,00001)-10000" | bC | sed 's/\([0-9][0-9]\)$/,\1/')

verwenden.


Ein anderes Beispiel:
Man hat eine Reihe von Meßwerten in der Form (x;y) die durch Leerzeichen oder Tabulatorzeichen getrennt in einer Datei hD.txt im Ordner ~/Bla stehen. Aufruf
gedit ~/Bla/hD.txt
ergibt in diesem Beispiel
1,4 5,33
2,8 6,279
3,1 6,806
4,7 10,612
5,8 14,08
6,6 18,5
7,9 22,04
9,1 24,91
10,3 26,004
11,9 26,776
Wichtig ist daß der blinkende Cursor in der Datei ganz unten hinter der letzten Zahl steht und nicht in einer neuen Zeile unter den Zahlen. Sonst drückt man die Rückwärtstaste damit der blinkende Cursor hinter dem letzten Zahlenwert erscheint und speichert. Ansonsten hat man eine zusätzliche LEERZEILE, die man entfernen müßte.

Man kann sich diese Meßwerte als Funktion y=y(x) vorstellen

Es läßt sich eine Kurve erahnen von der man die Tangentensteigung bestimmen möchte - also bei den vorgegebenen x-Meßwerten y'(x). Näherungsweise läßt sich dies durch einen Differenzenquotienten berechnen 
y'(x)~[y(nachx) - y(vorx)]/[nachx - vorx]
Dabei ist nachx der in der Reihenfolge nach x notierte Wert
und vorx der in der Reihenfolge vor x notierte Wert.
Zum Bearbeiten ist es sinnvoll eine Datei zu haben bei der in einer Zeile die Daten
vorher aktuell nachher
notiert sind, so wie in dem gelb markierten Bereich:

Also die vorhandene Datei dreimal versetzt aneinanderkleben wobei die entsprechenden Zeilen gelöscht werden. Dies macht die folgende Variable
hDz=$(paste <(sed '$d' < hD.txt | sed '$d') <(sed '1d;$d' < hD.txt) <(sed '1,2d' < hD.txt))

echo "$hDz"

Man wünscht eine Tabelle der Form
x  y(x)  y'(x)   natürlich mit einem angenäherten y'(x)
Dies erreicht man durch (zum Schluß vielleicht noch ein wenig Kosmetik)
VNx=$(while read vorx vory x y nachx nachy; do GS=$(echo "($nachy - $vory)/($nachx - $vorx)" | bC -l); echo "$x $y $GS"; done <<<$hDz)

echo "$VNx" | column -t


Noch eine Anmerkung zu der Erzeugung der obigen 30 Variablen mit read. Da read nur die erste Zeile liest kann man
head -n 1
weglassen und diese 30 Variablen erzeugen durch

for i in {01..30}; do read zS$i <<< $(cat ~/.meine_sonderzeichen/zS$i.txt | cut -c 1-10); done

Man kann also keine mehrzeiligen Variablen auf diese Art mit read erzeugen. Aber es gibt eine andere Möglichkeit auch mehrzeilige Variablen zu erzeugen. So kann man die erste Variable auf dieser Seite 
dN
als (spaltenartige oder mehrzeilige) Variable erzeugen durch

printf -v dN "$(cat hK.txt)"

echo "$dN"
1:28:2:3:0:1
2:8:3:1:1:0
2:31:8:11:3:0
2:18:4:3:4:0

Auf der Seite Debian Gnome Programmfenster Zwischenablage
wurden 8 (mehrzeilige) Variablen definiert:

zA1=$(cat ~/.meine_zwischenablage/zA1.txt | cut -c 1-60 | head -n 3)
zA2=$(cat ~/.meine_zwischenablage/zA2.txt | cut -c 1-60 | head -n 3)
zA3=$(cat ~/.meine_zwischenablage/zA3.txt | cut -c 1-60 | head -n 3)
zA4=$(cat ~/.meine_zwischenablage/zA4.txt | cut -c 1-60 | head -n 3)
zA5=$(cat ~/.meine_zwischenablage/zA5.txt | cut -c 1-60 | head -n 3)
zA6=$(cat ~/.meine_zwischenablage/zA6.txt | cut -c 1-60 | head -n 3)
zA7=$(cat ~/.meine_zwischenablage/zA7.txt | cut -c 1-60 | head -n 3)
zA8=$(cat ~/.meine_zwischenablage/zA8.txt | cut -c 1-60 | head -n 3)

Dies kann man so machen:
for i in {1..8}; do printf -v zA$i "$(cat ~/.meine_zwischenablage/zA$i.txt | cut -c 1-60 | head -n 3)"; done

zur Übersicht nächste Seite

Datenschutzerklärung
Impressum