myGully.com

myGully.com (https://mygully.com/index.php)
-   Entwicklung & Programmierung (https://mygully.com/forumdisplay.php?f=72)
-   -   Zeit aus csv-Datei (https://mygully.com/showthread.php?t=2589603)

Wasabi72 13.03.12 07:41
Zeit aus csv-Datei
 
Hallo,

ich habe hier eine csv Datei mit 4 Spalten mit Zeitangaben im Format mm:ss
Code:
T1;T2;T3;Tges
04:48;02:20;00:16;07:24
04:34;02:27;00:42;07:43
07:34;03:04;00:00;10:38
03:09;05:13;00:00;08:22
05:49;04:09;00:33;10:31
04:30;01:58;00:40;07:07
07:26;05:47;00:42;13:56
Mein Boss möchte nun die Durchschnittswerte jeder Spalte ganz simpel via php ins Intranet stellen.
Jegliche Anleitung die ich bisher im Netz gefunden habe verwirrt mich mehr. Vor allem diese Umrechnung von den Zeitangaben :dozey:
Hat jemand einen Anhaltspunkt wie ich das am besten mache ?

Wasabi72 13.03.12 17:46
Mag sein das es für Dich nicht anspruchsvoll ist :) Für mich schon :(
Bei mir fängst schon damit an wie ich jede Spalte(also T1;T2;T3;Tges) für sich da mit php extrahieren soll.
Dann noch das Problem das man die Zeitangaben scheinbar erst von mm:ss in ss umrechnen muss damit was gescheites am Ende raus kommt.
Glaub mir, ich hab schon viele Seiten inkl das php-manual im Netz aufgesucht, aber irgendwie passen die Lösungen nie genau zu meiner Aufgabe.

:(

Wasabi72 13.03.12 18:31
:(
Hatte wohl vergessen zu schreiben das dies meine ersten Schritte in PHP sind.
Somit ist es für mich vergleichsweise so als würde ich japanisch lernen.



.

Wasabi72 14.03.12 07:06
Also bin schon etwas weiter, aber noch nicht da wo ich hin will:

Mit folgenden Code kann ich die erste Spalte "T1" auslesen und den Durchschnitt berechnen.
Leider werden nur die ersten beiden Ziffern (also die Minuten) berücksichtigt, die Sekunden werden ignoriert.
Wie, wo passe ich das jetzt an das die Komplette Zeit Minuten und Sekunden (mm:ss) mit in die Berechnung mit einbezogen werden ?

PHP-Code:
<?php
$fp = @fopen("meine_csv_datei.csv", "r") or die ("Datei nicht lesbar.");
$zeile = fgets($fp, 1000);
$t1 = 0;
$t1 = array();
while($zeile = fgets($fp, 1000))
{
$spalten = explode(";", $zeile);
$t1[] += $spalten[0];
}
fclose($fp);

echo "T1: ";
echo array_sum($t1)/count($t1);

?>
Danke.

Epeos 14.03.12 13:20
Also: Mit explode teilst Du Deine Zeile auf. $spalten ist ein Array. Den ersten Wert hast Du ja schon mit $spalten[0] angesprochen. die anderen 3 Werte kriegst Du genauso mit $spalten[1], ..., $spalten[3]

In $spalten[0] steht immer noch eine Zeitangabe. Damit kann php nicht rechnen. Du hast jetzt zwei Möglichkeiten: Entweder Du schaust Dir die DateTime-Klassen von php an. Die können mit Datum- und Zeitangaben rechnen. Das ist aber für die Aufgabe ein bisschen Overkill.
Oder Du schreibst Dir die Addition selbst. Dazu explodest du jede Zeitangabe am ":". Dann kriegst Du wieder ein Array mit den Minuten und Sekunden einzeln. Mit den einzelnen Werten kannst Du dann einzeln vernünftig rechnen.

Wasabi72 14.03.12 18:14
Mh,
also nach dem Explode für ";" soll noch eine Explode für ":" ??
Ich hab gar kein Plan wo ich dies einbauen soll... Google hilft mir da selbt nach Stunden nicht weiter.
Vermutlich hat sowas noch nie einer benötigt :-)

Wasabi72 16.03.12 07:38
So,

jetzt hab ich schon mal rausgefunden wie ich Zeiten im Format mm:ss aufspalten und zu Sekunden zusammenrechnen kann.
Im folgendem Beispiel zerlege ich die 12Minuten und 45Sekunden:
PHP-Code:
$time = '12:45';
$time=explode(':',$time);
$sec =$time[0]*60;
$sec+=$time[1];
echo $sec; 
Ergebnis: 765

Im Beispiel wird ja bei "$time" nur die eine extra platzierte Zeitangabe 12:45 zerlegt.
Wie bau ich dieses S***** jetzt in das andere ein, so das er die Zeiten spaltenweise zerlegt, zusammenrechnet und dann den Durchschnitt ausspuckt.




.

Epeos 16.03.12 21:46
Für den Anfang musst Du doch nur die Zeile
PHP-Code:
$t1[] += $spalten[0]; 
mit Deinem neuen Skript ergänzen. Du darfst halt nicht $spalten[0] addieren, sondern dsa Ergebnis Deiner Berechnung.

Als nächstes schaust Du Dir for-Schleifen an und erweiterst damit Dein Skript auch auf die Spalten T2, T3 und Tges

(Hinweis: Du kannst Array-Elemente auch mit Variablen ansprechen:
PHP-Code:
$a = array(3,8,16,32);
$summe = 0;
for ($i=0;$i<4;$i++) {
    $summe += $a[$i];
} 
berechnet Dir z.B. die Summe der 4 Zahlen im Array.

Wasabi72 17.03.12 13:20
So,
keine Ahnung was ich hier falsch mache, aber ich bekomme immer durch das zweite explode den Fehler:
Warning: explode() expects parameter 2 to be string, array given in /www/htdocs/blabla/bla/bla.php on line 10
Verstehe nur Bahnhof.
So siehts derzeit aus:
PHP-Code:
<?php
$fp = @fopen("meine_csv_datei.csv", "r") or die ("Datei nicht lesbar.");
$zeile = fgets($fp, 1000);
$t1 = 0;
$t1 = array();
while($zeile = fgets($fp, 1000))
{
$spalten = explode(";", $zeile);
$t1[] = $spalten[0];
$t1 = explode(':',$t1);
$sec = $t1[0]*60;
$sec += $t1[1];
}
fclose($fp);
echo $sec;

/* $array = explode(":", $t1);
$zeit[] += $array[0];
echo array_sum($t1)/count($t1); */
?>

smdata2 17.03.12 14:52
Hm ein ganz interessantes Beispiel finde ich :) Also habe ich mich mal rangesetzt, weil es mich selber auch interessiert, hat wie das am Besten geht:

PHP-Code:
<?php
// CSV-Datei öffnen
$fh = fopen('bsp.csv', 'r');
$lines = array();
// Zeilenweise einlesen (fgetcsv für gleichzeitiges Lesen und "Splitten")
while(($line = fgetcsv($fh, 0, ';')) !== false) {
  $lines[] = $line;
}
// Datei schließen
fclose($fh);

/*
 * 2-Dimensionales Array ablaufen und Zeiten aufsummieren
 * ACHTUNG: i-Schleife beginnt mit 1 um die Kopfzeile der CSV-Datei zu überspringen
 */
$sums = array();
for($i=1; $i<count($lines); $i++) {
  for($j=0; $j<count($lines[$i]); $j++) {
    // Falls es der erste Durchlauf ist, wird die Summe mit 0 vorbelegt
    if(!isset($sums[$j]))
      $sums[$j] = 0;
    
    // Wert nach Minuten und Sekunden auftrennen und als Sekundenwert ablegen
    $time = preg_split('/:/', $lines[$i][$j]);
    $seconds = $time[0] * 60 + $time[1];
    $sums[$j] += $seconds;
  }
}

/*
 * Durchschnitt der einzelnen Spalten bilden
 */
$averages = array();
for($i=0; $i<count($sums); $i++) {
  // Summe aus dem Array holen und durch Anzahl der Zeilen - 1 (Erneut wegen Kopfzeile der CSV-Datei) teilen
  // --> ergibt den Durchschnittswert in Sekunden
  $seconds = $sums[$i] / (count($lines) - 1);
  // Volle Minuten bestimmen, eventuell mit führender 0
  $avg_minutes = str_pad(floor($seconds / 60), 2, '0', STR_PAD_LEFT);
  $avg_seconds = str_pad(($seconds % 60), 2, '0', STR_PAD_LEFT);
  $averages[] = $avg_minutes . ':' . $avg_seconds; 
}

// Testweise ausgeben lassen :)
print_r($averages);
Erzeugt mit deinen Daten folgende Ausgabe:
Code:
Array
(
    [0] => 05:24
    [1] => 03:34
    [2] => 00:24
    [3] => 09:23
)
Hoffe dass es dir und vielleicht auch anderen weiterhilft ;)

Wasabi72 17.03.12 16:13
Hui,
das klappt schonmal.
Jetzt habe ich bei den aktuellen Live-Daten der csv aber festgestellt das dort auch Zeilen ohne Inhalt geführt werden.
Code:
;;;
06:46;02:46;01:03;10:36
;;;
04:30;00:52;00:19;05:40
05:48;03:05;00:48;09:42
03:31;02:59;00:23;06:53
03:50;03:07;00:30;07:27
;;;
06:14;03:27;01:23;11:03
03:57;04:59;00:50;09:46
;;;
05:12;03:48;00:47;09:47
;;;
;;;
Dadurch wird aber der Durchschnittswert verfälscht.

Kann man das irgendwie berücksichtigen ??
Sowas wie "wenn Zeilenwert = 0, dann gehe weiter ohne Zeile zu zählen"

.

smdata2 17.03.12 22:07
Dafür würde ich folgendes machen:

1:
Die Spalten einer Zeile werden nur durchlaufen wenn mindestens der erste Wert ungleich 0 ist:
PHP-Code:
/*
 * 2-Dimensionales Array ablaufen und Zeiten aufsummieren
 * ACHTUNG: i-Schleife beginnt mit 1 um die Kopfzeile der CSV-Datei zu überspringen
 */
$sums = array();
$count = 0;
for($i=1; $i<count($lines); $i++) {
  if(!empty($lines[$i][0])) {
    $count++;
    for($j=0; $j<count($lines[$i]); $j++) {
      // Falls es der erste Durchlauf ist, wird die Summe mit 0 vorbelegt
      if(!isset($sums[$j]))
        $sums[$j] = 0;
      
      // Wert nach Minuten und Sekunden auftrennen und als Sekundenwert ablegen
      $time = preg_split('/:/', $lines[$i][$j]);
      $seconds = $time[0] * 60 + $time[1];
      $sums[$j] += $seconds;
    }
  }
} 
2:
Bei der Bildung des Durchschnitts kann jetzt nicht mehr einfach $lines - 1 als Anzahl genommen werden, stattdessen wird nun der vorher ermittelte Wert $count genommen:
PHP-Code:
/*
 * Durchschnitt der einzelnen Spalten bilden
 */
$averages = array();
for($i=0; $i<count($sums); $i++) {
  // Summe aus dem Array holen und durch Anzahl der Zeilen (in $count ermittelt) teilen
  // --> ergibt den Durchschnittswert in Sekunden
  $seconds = $sums[$i] / $count;
  // Volle Minuten bestimmen, eventuell mit führender 0
  $avg_minutes = str_pad(floor($seconds / 60), 2, '0', STR_PAD_LEFT);
  $avg_seconds = str_pad(($seconds % 60), 2, '0', STR_PAD_LEFT);
  $averages[] = $avg_minutes . ':' . $avg_seconds; 
} 
Hoffe, dass es dich weiterbringt! :)

Wasabi72 18.03.12 05:41
@ smdata2

Das sieht sehr gut aus.
Aber leider hatte ich bei der csv nicht alle Inhalte mit angegeben (Asche auf mein Haupt :( ) .
Vor und nach den Zeiten (T1, T2, T3, Tges) sind noch diverse andere Spalten die immer mit Daten gefüllt sind. Und diese verhindern jetzt vermutlich die neue Berechnung.
Besteht die Möglichkeit die Durchschnittsberechnung nur auf genau diese 4 Spalten (T1, T2, T3, Tges) zu fokussieren ?

Epeos 18.03.12 10:28
Ja. Die innere for-Schleife bei smdata2s Lösung regelt, welche Spalten berücksichtigt werden.

PHP-Code:
for($i=1; $i<count($lines); $i++) {
  //festlegen, welches die Start- und Ende-Spalten sind, dabei hat die erste Spalte den Index 0
  //Hier im Beispiel werden die 2., 3. und 4. Spalte in der Auswertung berücksichtigt
  $startspalte = 1;
  $endespalte = 4;
  for($j=$startspalte; $j<$endespalte; $j++) {
    // Falls es der erste Durchlauf ist, wird die Summe mit 0 vorbelegt
    if(!isset($sums[$j]))
      $sums[$j] = 0;
    
    // Wert nach Minuten und Sekunden auftrennen und als Sekundenwert ablegen
    $time = preg_split('/:/', $lines[$i][$j]);
    $seconds = $time[0] * 60 + $time[1];
    $sums[$j] += $seconds;
  }
} 

Wasabi72 18.03.12 12:03
Igendwie rechnet das nicht wirklich korrekt. :(
Hier mal eine Test csv mit allen Spalten:
Code:
pack;set;runs;T1;T2;T3;Tges;Datum;Zeit;out;other;zero;percent
7480;31260;;;;;;17.03.2012;16:30;08:22;38;;68%
77754;9702;27;06:46;02:46;01:03;10:36;17.03.2012;16:30;08:22;38;;68%
2356;41294;;;;;;17.03.2012;16:30;08:22;38;;68%
45564;91278;68;04:30;00:52;00:19;05:40;17.03.2012;16:30;08:22;38;;68%
23566;91249;37;05:48;03:05;00:48;09:42;17.03.2012;16:30;08:22;38;;68%
88932;41625;47;03:31;02:59;00:23;06:53;17.03.2012;16:30;08:22;38;;68%
93136;91218;45;03:50;03:07;00:30;07:27;17.03.2012;16:30;08:22;38;;68%
65337;84681;;;;;;17.03.2012;16:30;08:22;38;;68%
22345;41215;28;06:14;03:27;01:23;11:03;17.03.2012;16:30;08:22;38;;68%
46485;84601;35;03:57;04:59;00:50;09:46;17.03.2012;16:30;08:22;38;;68%
81614;16179;;;;;;17.03.2012;16:30;08:22;38;;68%
41603;81271;42;05:12;03:48;00:47;09:47;17.03.2012;16:30;08:22;38;;68%
46407;84612;;;;;;17.03.2012;16:30;08:22;38;;68%
46408;84621;;;;;;17.03.2012;16:30;08:22;38;;68%
5734;6773;;;;;;17.03.2012;16:30;08:22;38;;68%
46477;84671;;;;;;17.03.2012;16:30;08:22;38;;68%
3435;7778;32;06:32;03:38;01:35;11:45;17.03.2012;16:30;10:24;38;;68%
4357;44567;27;06:54;03:39;00:47;11:20;17.03.2012;16:30;10:24;38;;68%
81296;63113;;;;;;17.03.2012;16:30;10:24;38;;68%
16129;26611;31;07:10;01:20;00:33;09:03;17.03.2012;16:30;10:52;38;;68%
Startspalte ist 3, Endspalte ist 7, und hier das berechnete Ergebnis:
Array ( [0] => 00:00 [1] => 00:00 [2] => 00:00 [3] => 03:01 )

Hier das komplette S*****:
PHP-Code:
<?php
// CSV-Datei öffnen
$fh = fopen('aht.csv', 'r');
$lines = array();
// Zeilenweise einlesen (fgetcsv für gleichzeitiges Lesen und "Splitten")
while(($line = fgetcsv($fh, 0, ';')) !== false) {
  $lines[] = $line;
}
// Datei schließen
fclose($fh);

/*
 * 2-Dimensionales Array ablaufen und Zeiten aufsummieren
 * ACHTUNG: i-Schleife beginnt mit 1 um die Kopfzeile der CSV-Datei zu überspringen
 */
$sums = array();
$count = 0;
for($i=1; $i<count($lines); $i++) {
  if(!empty($lines[$i][0])) {
    $count++;    
  //festlegen, welches die Start- und Ende-Spalten sind, dabei hat die erste Spalte den Index 0
  //Hier im Beispiel werden die 2., 3. und 4. Spalte in der Auswertung berücksichtigt
  $startspalte = 3;
  $endespalte = 7;
  for($j=$startspalte; $j<$endespalte; $j++) {
    // Falls es der erste Durchlauf ist, wird die Summe mit 0 vorbelegt
    if(!isset($sums[$j]))
      $sums[$j] = 0;
    
    // Wert nach Minuten und Sekunden auftrennen und als Sekundenwert ablegen
    $time = preg_split('/:/', $lines[$i][$j]);
    $seconds = $time[0] * 60 + $time[1];
    $sums[$j] += $seconds;
  }
 }   
}
/*
/*
 * Durchschnitt der einzelnen Spalten bilden
 */
$averages = array();
for($i=0; $i<count($sums); $i++) {
  // Summe aus dem Array holen und durch Anzahl der Zeilen (in $count ermittelt) teilen
  // --> ergibt den Durchschnittswert in Sekunden
  $seconds = $sums[$i] / $count;
  // Volle Minuten bestimmen, eventuell mit führender 0
  $avg_minutes = str_pad(floor($seconds / 60), 2, '0', STR_PAD_LEFT);
  $avg_seconds = str_pad(($seconds % 60), 2, '0', STR_PAD_LEFT);
  $averages[] = $avg_minutes . ':' . $avg_seconds; 
}  

// Testweise ausgeben lassen :)
print_r($averages);
Hab ich was übersehen ??

.

Epeos 18.03.12 20:35
Ne, aber ich, sorry. Im Duchschnittbildenteil muss natürlich auch startspalte und endespalte verwendet werden:

PHP-Code:
/*
 * Durchschnitt der einzelnen Spalten bilden
 */
$averages = array();
for($i=$startspalte; $i<$endespalte; $i++) {
  // Summe aus dem Array holen und durch Anzahl der Zeilen (in $count ermittelt) teilen
  // --> ergibt den Durchschnittswert in Sekunden
  $seconds = $sums[$i] / $count;
  // Volle Minuten bestimmen, eventuell mit führender 0
  $avg_minutes = str_pad(floor($seconds / 60), 2, '0', STR_PAD_LEFT);
  $avg_seconds = str_pad(($seconds % 60), 2, '0', STR_PAD_LEFT);
  $averages[] = $avg_minutes . ':' . $avg_seconds; 
} 

Wasabi72 18.03.12 23:08
Danke bis hier hin :T
Irgendwie passt das was dabei raus kommt aber nicht wirklich:
Array ( [0] => 03:01 [1] => 01:41 [2] => 00:26 [3] => 05:09 )

Ich habe mal die Spalte 0 (T1) mit den genannten Werten manuell ausgerechnet und komme dabei auf insgesamt 3624 Sekunden.
Diese teile ich nun durch 11 (die Zeilen mit Inhalt in den Feldern T1 bis Tges) und erhalte als Durchschnitt 329,454545 Sekunden
was im Format mm:ss wiederum gerundet 05:29 ergibt.

Ich vermute mal das das S***** wieder die Sekunden durch alle Zeilen (in dem Fall 20) teilt. :(

.

smdata2 19.03.12 11:33
Ja der Code zur Ermittlung der Zeilen arbeitet nur auf Grundlage der ersten Spalte, d.h. wenn in der ersten Spalte nur 5 Werte stehen und in anderen Spalten aber 10 oder 15 Werte führt ist die Durchschnittsberechnung falsch :/

Ich gucke mir das heute Abend mal an, ist das letzte Beispiel an Daten jetzt eine vollständige Datei bezüglich der Spaltenstruktur? Sonst macht es wenig Sinn das Skript wieder an das "neue" Format anzupassen :D

Wasabi72 19.03.12 13:20
Ja, die Spalten im letzten Beispiel passen.....live ist das Teil aber länger ;)
Danke :T

smdata2 19.03.12 17:48
Okay das ist nicht das Problem :) Aber eine Frage hab ich noch: Soll jetzt von allen Spalten der Durchschnittswert berechnet werden oder nur von den Spalten T1 bis Tges?

Wasabi72 19.03.12 19:16
Hi,
es betrifft nur die Spalten T1 bis Tges ;)

smdata2 19.03.12 19:46
Soo meiner Meinung nach funktioniert es, es kommen jedenfalls die gleichen Werte wie mit der MITTELWERT()-Funktion von Excel raus :)
Sag einfach Bescheid! ;)

Edit: Die Änderungen sind eigentlich, dass nun nicht das erste Feld der Spalte, sondern das Feld mit dem Index $startspalte geprüft wird, sowie die Anweisung array_values nach der Summation, um unabhängig von den Spaltenindizes die Summen einfacher durchlaufen zu können.

PHP-Code:
<?php 
// CSV-Datei öffnen 
$fh = fopen('bsp3.csv', 'r'); 
$lines = array(); 
// Zeilenweise einlesen (fgetcsv für gleichzeitiges Lesen und "Splitten") 
while(($line = fgetcsv($fh, 0, ';')) !== false) { 
  $lines[] = $line; 
} 
// Datei schließen 
fclose($fh); 

/* 
 * 2-Dimensionales Array ablaufen und Zeiten aufsummieren 
 * ACHTUNG: i-Schleife beginnt mit 1 um die Kopfzeile der CSV-Datei zu überspringen 
 */ 
$sums = array(); 
$count = 0;
for($i=1; $i<count($lines); $i++) {     
  // Festlegen, welches die Start- und Ende-Spalten sind, dabei hat die erste Spalte den Index 0 
  $startspalte = 3; 
  $endespalte = 7;
  if(!empty($lines[$i][$startspalte])) { 
    $count++; 
  for($j=$startspalte; $j<$endespalte; $j++) { 
    // Falls es der erste Durchlauf ist, wird die Summe mit 0 vorbelegt 
    if(!isset($sums[$j])) 
      $sums[$j] = 0; 
     
    // Wert nach Minuten und Sekunden auftrennen und als Sekundenwert ablegen 
    $time = preg_split('/:/', $lines[$i][$j]); 
    $seconds = $time[0] * 60 + $time[1]; 
    $sums[$j] += $seconds; 
  } 
 }    
}
// Durch array_values werden die Indizes des Arrays umgewandelt, um den Durchschnitt einfacher
// berechnen zu können (siehe http://php.net/manual/de/function.array-values.php)
$sums = array_values($sums);
 
/* 
/* 
 * Durchschnitt der einzelnen Spalten bilden 
 */ 
$averages = array(); 
for($i=0; $i<count($sums); $i++) { 
  // Summe aus dem Array holen und durch Anzahl der Zeilen (in $count ermittelt) teilen 
  // --> ergibt den Durchschnittswert in Sekunden 
  $seconds = $sums[$i] / $count; 
  // Volle Minuten bestimmen, eventuell mit führender 0 
  $avg_minutes = str_pad(floor($seconds / 60), 2, '0', STR_PAD_LEFT); 
  $avg_seconds = str_pad(($seconds % 60), 2, '0', STR_PAD_LEFT); 
  $averages[] = $avg_minutes . ':' . $avg_seconds;  
}   

// Testweise ausgeben lassen :) 
print_r($averages);

Epeos 19.03.12 20:05
Habs ein bisschen umgebaut:

PHP-Code:
<?php
// CSV-Datei öffnen
$fh = fopen('aht.csv', 'r');
$lines = array();
// Zeilenweise einlesen (fgetcsv für gleichzeitiges Lesen und "Splitten")
while(($line = fgetcsv($fh, 0, ';')) !== false) {
  $lines[] = $line;
}
// Datei schließen
fclose($fh);

//festlegen, welches die Start- und Ende-Spalten sind, dabei hat die erste Spalte den Index 0
$startspalte = 3;
$endespalte = 7;

/*
 * 2-Dimensionales Array ablaufen und alle nichtleeren Zeiten in neues Array kopieren
 * ACHTUNG: i-Schleife beginnt mit 1 um die Kopfzeile der CSV-Datei zu überspringen
 */
$tinseconds = array();
$count = 0;
for($i=1; $i<count($lines); $i++) {
  for($j=$startspalte; $j<$endespalte; $j++) {
    if (!empty($lines[$i][$j])) {

        // Wert nach Minuten und Sekunden auftrennen und als Sekundenwert ablegen
        $time = preg_split('/:/', $lines[$i][$j]);
        $seconds = $time[0] * 60 + $time[1];
        $tinseconds[$j][] = $seconds;
    }
  }
}

/* $tinseconds sieht in etwa so aus:
 * $tinseconds[3] alle Werte aus Spalte 3
 * $tinseconds[4] alle Werte aus Spalte 4; die Anzahl muss nicht mit $tinseconds[3] übereinstimmen
 * ...
 */

/*
/*
 * Durchschnitt der einzelnen Spalten bilden
 */
$averages = array();
for($i=$startspalte; $i<$endespalte; $i++) {
  // Über die einzelnen Spalten Summe bilden und durch Anzahl der Einträge teilen
  // --> ergibt den Durchschnittswert in Sekunden
  if (count($tinseconds[$i])>0) {
    $seconds = array_sum($tinseconds[$i]) / count($tinseconds[$i]);
    // Volle Minuten bestimmen, eventuell mit führender 0
    $avg_minutes = str_pad(floor($seconds / 60), 2, '0', STR_PAD_LEFT);
    $avg_seconds = str_pad(($seconds % 60), 2, '0', STR_PAD_LEFT);
    $averages[] = $avg_minutes . ':' . $avg_seconds; 
  }
}  

// Testweise ausgeben lassen :)
print_r($averages);
Bei T1 komm ich auf Deine Zeit. Rest hab ich nicht nachgerechnet. Das funktioniert jetzt auch, wenn einzelne Werte in T1, T2, T3 oder TGes nicht gesetzt sind.

smdata2 19.03.12 20:09
Jo so kann man es auch machen beide Ansätze sollten passen, wobei deiner für den Fall unregelmäßiger Zeilen besser geeignet sein sollte aber sonst gibts das gleiche Ergebnis :)

Wasabi72 21.03.12 17:41
An dieser Stelle mal ein herzliches Danke an alle Beteiligten !!!
:T:T:T


.

Wasabi72 22.04.12 15:12
Hallo,

steh mal wieder aufm Schlauch :confused:

Wie bekomme ich aus einer csv-Datei ganz simpel eine vorhandene Zeitangabe mm:ss (Minuten:Sekunden) zusätzlich in Sekunden umgerechnet ?

Aktuell sieht das so bei mir aus:
Code:
<?php
$fp = @fopen("http://www.domain.de/data.csv", "r") or die ("Datei nicht lesbar.");
$zeile = fgets($fp, 1000);
$rrr = 0;
$rrr = array();
 
while($zeile = fgets($fp, 1000))
{
$spalten = explode(";", $zeile);
$tt[] .= $spalten[9];
}
fclose($fp);

<?php print_r($tt[10]); ?>

?>
Es wird eine bestimmte Spalte und dort eine bestimmte Zelle abgefragt.
Und dort sieht es halt immer so aus...z.B : 06:15 --> also 6Minuten und 15Sekunden.
Jetzt wäre es toll den Wert zusätzlich noch in Sekunden anzeigen zu lassen....also im Beispiel dann 375

Ist bestimmt simpel......habs mit folgenden Code erfolglos versucht:
Code:
list($mins,$secs) = explode(':',$spalten[9]);
$seconds2 = mktime($mins,$secs);

Wasabi72 22.04.12 20:21
Also die Minuten aus den verschiedenen Zeilen der vorgegebenen Spalte bekomme ich ja wie folgt:
Code:
<?php print_r($tt[10]); ?>
<?php print_r($tt[30]); ?>
<?php print_r($tt[52]); ?>
<?php print_r($tt[72]); ?>
<?php print_r($tt[94]); ?>
<?php print_r($tt[110]); ?>
<?php print_r($tt[131]); ?>
<?php print_r($tt[151]); ?>

Für die Sekunden habe ich nun folgendes "gebastelt" und in den vorhandenen Code eingebaut:
Code:
$time01=explode(':', $tt[10]);
$sec01 =$time01[0]*60;
$sec01+=$time01[1];
$sec01 = round($sec01,0);

$time02=explode(':', $tt[30]);
$sec02 =$time02[0]*60;
$sec02+=$time02[1];
$sec02 = round($sec02,0);

$time03=explode(':', $tt[52]);
$sec03 =$time03[0]*60;
$sec03+=$time03[1];
$sec03 = round($sec03,0);

$time04=explode(':', $tt[72]);
$sec04 =$time04[0]*60;
$sec04+=$time04[1];
$sec04 = round($sec04,0);

$time05=explode(':', $tt[94]);
$sec05 =$time05[0]*60;
$sec05+=$time05[1];
$sec05 = round($sec05,0);

$time06=explode(':', $tt[110]);
$sec06 =$time06[0]*60;
$sec06+=$time06[1];
$sec06 = round($sec06,0);

$time07=explode(':', $tt[131]);
$sec07 =$time07[0]*60;
$sec07+=$time07[1];
$sec07 = round($sec07,0);

$time08=explode(':', $tt[151]);
$sec08 =$time08[0]*60;
$sec08+=$time08[1];
$sec08 = round($sec08,0);
Da wird also die fertige Zeit in Minuten genommen, zerteilt und in Sekunden umgerechnet. Leider eben für jeden der 8 Zeitangaben einzeln.
Angezeigt wird das dann so:
Code:
<?php print_r($sec01); ?>
<?php print_r($sec02); ?>
<?php print_r($sec03); ?>
<?php print_r($sec04); ?>
<?php print_r($sec05); ?>
<?php print_r($sec06); ?>
<?php print_r($sec07); ?>
<?php print_r($sec08); ?>
Ich vermute mal das es auch einfacher geht......nur wie ??

ProgMaster 22.04.12 21:13
Schleife?


Alle Zeitangaben in WEZ +1. Es ist jetzt 07:54 Uhr.

Powered by vBulletin® (Deutsch)
Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.