090_datetime.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modul datetime\n",
    "\n",
    "Das datetime Modul bietet Funktionen zum Rechnen mit Datum und Zeit. </br>\n",
    "<a href=\"https://docs.python.org/3/library/datetime.html\"> PythonDoc </a>   -\n",
    "<a href=\"https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior\"> strftime </a> </br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import datetime as dt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date(2017, 10, 24)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = dt.date(2016,11,24)\n",
    "d2 = dt.date(2017,10,24)\n",
    "max(d1,d2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "334 days, 0:00:00\n"
     ]
    }
   ],
   "source": [
    "print(d2 - d1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nützliche Typen\n",
    "Das datetime-Modul stellt folgende Typen zur Verfügung\n",
    "* date: speichert ein Datum (Jahr, Monat, Tag)\n",
    "* time: speichert die Zeit (Stunden, Minuten, Sekunden)\n",
    "* datetime: speichert Datum und Zeit  \n",
    "* timedelta: Zeit zwischen zwei date-Objekten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### datetime.date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'datetime.timedelta'>\n",
      "7031 days, 0:00:00\n",
      "7031\n"
     ]
    }
   ],
   "source": [
    "anfang_jahrhundert = dt.date(2000,1,1)\n",
    "heute = dt.date.today()\n",
    "diff = heute - anfang_jahrhundert \n",
    "print(type(diff))\n",
    "print(diff)\n",
    "print(diff.days)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>datetime.datetime</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-04-02 07:55:25.159380\n",
      "2000-01-01 00:00:00\n",
      "7031 days, 7:55:25.159380\n",
      "7031\n"
     ]
    }
   ],
   "source": [
    "anfang_jahrhundert = dt.datetime(2000,1,1,0,0,0)\n",
    "jetzt = dt.datetime.now()\n",
    "diff = jetzt - anfang_jahrhundert\n",
    "print(jetzt)\n",
    "print(anfang_jahrhundert)\n",
    "print(diff)\n",
    "print(diff.days)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gültigkeit eines Datums</h4>\n",
    "Ein ValueError wird bei einem ungültigen Datum geworden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "day is out of range for month",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-8e42cd8d08a9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msome_date\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2015\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m29\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;31m#some_date = dt.date(2016,2,29)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;31m#some_time = dt.datetime(2015,2,28,23,60,0)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msome_date\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: day is out of range for month"
     ]
    }
   ],
   "source": [
    "some_date = dt.date(2015,2,29)\n",
    "#some_date = dt.date(2016,2,29)\n",
    "#some_time = dt.datetime(2015,2,28,23,60,0)\n",
    "print(some_date)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### datetime.timedelta \n",
    "Differenz zwischen date-Objekten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6948\n",
      "600307200.0\n",
      "10005120.0\n",
      "166752.0\n"
     ]
    }
   ],
   "source": [
    "anfang_jahrhundert = dt.date(2000,1,1)\n",
    "heute = dt.date.today()\n",
    "diff = heute - anfang_jahrhundert\n",
    "print(diff.days)                           # Tage\n",
    "print(diff.total_seconds())                # Sekunden        \n",
    "print(diff.total_seconds()/60)             # Minuten\n",
    "print(diff.total_seconds()/60/60)          # Stunden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Differenz zwischen datetime-Objekten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6948\n",
      "600373014.560464\n",
      "10006216.909341067\n",
      "166770.28182235113\n"
     ]
    }
   ],
   "source": [
    "anfang_jahrhundert = dt.datetime(2000,1,1,0,0,0)\n",
    "jetzt = dt.datetime.now()\n",
    "diff = jetzt - anfang_jahrhundert\n",
    "print(diff.days)                           # Tage\n",
    "print(diff.total_seconds())                # Sekunden        \n",
    "print(diff.total_seconds()/60)             # Minuten\n",
    "print(diff.total_seconds()/60/60)          # Stunden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Die aktuelle Uhrzeit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18:17:52.471102\n"
     ]
    }
   ],
   "source": [
    "jetzt = dt.datetime.now()\n",
    "uhrzeit = jetzt.time()\n",
    "print(uhrzeit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rechnen mit date- und datetime-Objekten\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-01-14\n"
     ]
    }
   ],
   "source": [
    "heute = dt.date.today()\n",
    "in_5_tagen = heute + dt.timedelta(days=5)\n",
    "print(in_5_tagen)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-10-25 10:55:08.501555\n"
     ]
    }
   ],
   "source": [
    "jetzt = dt.datetime.today()\n",
    "in_5min_5sec = jetzt + dt.timedelta(minutes=5,seconds=5)\n",
    "print(in_5min_5sec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-10-25 10:45:08.286259\n"
     ]
    }
   ],
   "source": [
    "jetzt = dt.datetime.today()\n",
    "vor_5min_5sec = jetzt + dt.timedelta(minutes=-5,seconds=-5)\n",
    "print(vor_5min_5sec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rechnen mit time-Objekten\n",
    "Rechnen mit timedelta geht bei date- und datetime-Objekten, aber nicht bei time-Objekten. Da bekommen wir einen TypeError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "uhrzeit = dt.datetime.now().time() #Returns the time component (drops the day)\n",
    "print(uhrzeit)\n",
    "spaeter = uhrzeit + dt.timedelta(seconds=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zum Rechnen mit time-Objekten schreiben wir eine eigene Funktion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def add_to_time(zeit,delta):\n",
    "    '''\n",
    "    zeit: time-Objekt\n",
    "    delta: timedelta-Objekt\n",
    "    returns: time-Objekt, um timedelta später als zeit\n",
    "    '''\n",
    "    temp = dt.datetime(1,1,1,zeit.hour,zeit.minute,zeit.second)\n",
    "    return (temp + delta).time()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19:43:17.223479 19:43:47\n"
     ]
    }
   ],
   "source": [
    "# Testen\n",
    "jetzt = dt.datetime.now().time()\n",
    "delta =dt.timedelta(seconds=30)\n",
    "print(jetzt,add_to_time(jetzt,delta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### datetime und strings \n",
    "Häufig erhält man ein Datum als String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String in Datum: datetime.strptime \n",
    "Häufig erhält man ein Datum als String.\n",
    "datetime.strptime() wandelt einen String in ein date-, datetime- oder time-Objekt um. Der Funktion muss\n",
    "eine __[Formatangabe](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)__ mitgegeben werden. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2003-04-01 00:00:00\n"
     ]
    }
   ],
   "source": [
    "date='01-Apr-03'\n",
    "date_object=dt.datetime.strptime(date,'%d-%b-%y')\n",
    "print(date_object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine entsprechende Umwandlung in ein timedelta-Objekt gibt es nicht. Wir können uns so behelfen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:15:30\n"
     ]
    }
   ],
   "source": [
    "fahrzeit = '2:15:30'\n",
    "h,m,s = fahrzeit.split(':')\n",
    "x = dt.timedelta(hours=int(h),minutes=int(m),seconds=int(s))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Datum in String: datetime.strftime\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.10.2018 10:52\n",
      "2018-10-25 10:52:40.726618\n"
     ]
    }
   ],
   "source": [
    "jetzt = dt.datetime.now()\n",
    "jetzt_string = dt.datetime.strftime(jetzt,'%d.%m.%Y %H:%M')\n",
    "print(jetzt_string)\n",
    "print(str(jetzt))    # die default-Umwandlung\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wochentage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Thursday'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heute = dt.date.today()\n",
    "print(heute.weekday())     # 0 - Montag, ... 6 - Sonntag\n",
    "heute.strftime(\"%A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Donnerstag'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import locale\n",
    "locale.setlocale(locale.LC_TIME,'')  # '' setzt die locale des Systems\n",
    "heute = dt.date.today()\n",
    "heute.strftime(\"%A\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aufgaben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bisWeihnachten():\n",
    "    '''\n",
    "    returns: int, Anzahl Tage von heute bis Weihnachten. \n",
    "        Am 24.12 wird der Wert 0 zurückgegeben.\n",
    "    '''\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def neueUhrzeit(jetzt, dauer):\n",
    "    '''\n",
    "    jetzt: String mit Uhrzeit im Format \"20:15:10\"\n",
    "    dauer: String mit Zeitdauer im Format \"200:10:05\" \n",
    "    returns: String mit der neuen Uhrzeit\n",
    "     \n",
    "    z.B. neueUhrzeit(20:15:10\",\"200:10:05\") \n",
    "        gibt die neue Uhrzeit zurück, nachdem 200 Stunden, 10 Minuten und 5 Sekunden verstrichen sind.\n",
    "    \n",
    "    '''\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wieviele(datum,bisjahr,wochentag):\n",
    "    '''\n",
    "    datum: datumsstring ohne jahr, z.B. \"14.04\" für 14. April\n",
    "    bisjahr: int, vierstellige Jahreszahl >= aktuelles Jahr, z.B. 2030\n",
    "    wochentag: String mit Wochentag, z.B. \"Montag\"\n",
    "    returns: int, Anzahl der Jahre bis bisjahr, in der das \n",
    "         Datum datum auf den Wochentag wochentag fällt.\n",
    "    \n",
    "    z.B. wieviel(\"14.04\",2030,\"Sonntag\") gibt zurück, wie häufig ab heute bis ins Jahr 2030 der 14.4. auf \n",
    "       einen Sonntag fällt.\n",
    "    '''\n",
    "    pass"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}