<jupyter_start><jupyter_text>Date+Time Basics **Inhalt:** Mit Zeit-Datentyp umgehen**Nötige Skills:** Erste Schritte mit Pandas**Lernziele:**- Text in Zeit konvertieren- Zeit in Text konvertieren- Zeit-Informationen extrahieren- Einfache Zeit-Operationen  Libraries<jupyter_code>import pandas as pd
from datetime import datetime
from datetime import timedelta<jupyter_output><empty_output><jupyter_text>Zeitformat Codes Extrakt, die volle Liste: http://strftime.org/. Diese Format-Codes brauchen wir, um mit Daten zu arbeiten. | Code | Description | *Example* ||--------|---------|--------|| **`%a`** | Weekday as locale’s abbreviated name. | *Mon* || **`%A`** | Weekday as locale’s full name. | *Monday* || **`%d`** | Day of the month as a zero-padded decimal number. | *30* || **`%-d`** | Day of the month as a decimal number. (Platform specific) | *30* || **`%b`** | Month as locale’s abbreviated name. | *Sep* || **`%B`** | Month as locale’s full name. | *September* || **`%m`** | Month as a zero-padded decimal number. | *09* || **`%-m`** | Month as a decimal number. (Platform specific) | *9* || **`%y`** | Year without century as a zero-padded decimal number. | *13* || **`%Y`** | Year with century as a decimal number. | *2013* || **`%H`** | Hour (24-hour clock) as a zero-padded decimal number. | *07* || **`%-H`** | Hour (24-hour clock) as a decimal number. (Platform specific) | *7* || **`%I`** |	Hour (12-hour clock) as a zero-padded decimal number. 	| *07* || **`%-I`** |	Hour (12-hour clock) as a decimal number. (Platform specific) 	| *7* || **`%p`** |	Locale’s equivalent of either AM or PM. 	| *AM* || **`%M`** | Minute as a zero-padded decimal number. | *06* || **`%-M`** | Minute as a decimal number. (Platform specific) | *6* || **`%S`** | Second as a zero-padded decimal number. | *05* || **`%-S`** | Second as a decimal number. (Platform specific) | *5* || **`%j`** | Day of the year as a zero-padded decimal number. | *273* || **`%-j`** | Day of the year as a decimal number. (Platform specific) | *273* || **`%U`** | Week number of the year (Sunday as the first day of the week) as a zero padded decimal number. All days in a new year preceding the first Sunday are considered to be in week 0. | *39* || **`%W`** | Week number of the year (Monday as the first day of the week) as a decimal number. All days in a new year preceding the first Monday are considered to be in week 0. | *39* || **`%c`** | Locale’s appropriate date and time representation. | *Mon Sep 30 07:06:05 2013* || **`%x`** | Locale’s appropriate date representation. | *09/30/13* || **`%X`** | Locale’s appropriate time representation. | *07:06:05* || **`%%`** | A literal '%' character. | *%*  Text to Time Eine häufige Situation, wenn man von irgendwo Daten importiert:- Wir haben einen bestimmten String, zB: "1981-08-23"- Wir wollen den String in ein Datetime-Objekt verwandeln, um sie zu analysieren- Dazu benutzen wir die Pandas-Funktion `to_datetime()`<jupyter_code>my_birthday_date = pd.to_datetime('1981-08-23', format='%Y-%m-%d') 

#funktion heisst .to_datetime: nimm den Textstring und mach ein Datum daraus.<jupyter_output><empty_output><jupyter_text>Das Ergebnis wird uns als "Timestamp" angezeigt.<jupyter_code>my_birthday_date<jupyter_output><empty_output><jupyter_text>Die Funktion erkennt einige Standardformate automatisch<jupyter_code>my_date = pd.to_datetime('1972-03-11 13:42:25')
my_date<jupyter_output><empty_output><jupyter_text>**Platz** zum ausprobieren. Kreiere ein Datetime-Objekt aus folgenden Strings:<jupyter_code># Beispiel: '23.08.1981'
my_date = pd.to_datetime('23.08.1981', format='%d.%m.%Y')
my_date
# Do it yourself: 'Aug 23, 1981'

dat1 = pd.to_datetime("Aug 23, 1981", format="%b %d, %Y")
dat1
# '18.01.2016, 18:25 Uhr'

dat2 = pd.to_datetime("18.01.2016, 18:25 Uhr" , format= "%d.%m.%Y, %H:%M Uhr")
dat2
# '5. May 2014'
dat3 = pd.to_datetime("5. May 2014", format='%d. %B %Y')
dat3
("5. Mai 2014").replace("Mai", "May")
# '5. Mai 2014'
my_date = pd.to_datetime('5. Mai 2014'.replace('Mai','May'), format='%d. %B %Y')
my_date<jupyter_output><empty_output><jupyter_text>Time to Text Brauchen wir typischerweise bei der Anzeige oder beim Export von DAten- Wir haben bereits ein Datetime-Objekt erstellt - jetzt wollen wir es nach einem bestimmten Schema anzeigen- dafür dient die Funktion `strftime()`, die jedes Datetime-Objekt hat Das Datums-Ojbekt haben wir bereits:<jupyter_code>my_date = pd.to_datetime('1981-08-23 08:15:25')<jupyter_output><empty_output><jupyter_text>Als Text:<jupyter_code>my_text = my_date.strftime(format='%Y-%m-%d')

# .strftime() (wie string for time), formatiere eine Zeit (Timestamp) als String. Gib ein sauberes Datum aus
my_text<jupyter_output><empty_output><jupyter_text>**Quiz**: Lass `strftime()` den folgenden Text ausgeben:<jupyter_code># Beispiel: 'Aug 23, 1981'
my_text = my_date.strftime(format="%b %d, %Y")
my_text
# Do it yourself: #'23.8.81, 08:15:25'
text1 = my_date.strftime(format="%d.%m.%Y, %H:%M:%S'")
text1
# 'Sunday, 23. of August 1981, 8:15 AM'
text2 = my_date.strftime(format="%A, %d. of %B, %-I:%M %p")
text2<jupyter_output><empty_output><jupyter_text>Time properties `strftime()` ist nicht die einzige Möglichkeit, Daten als Text anzuzeigen.Wir können auch direkt einzelne Eigenschaften eines Datetime-Objekts abfragen. Taken from https://pandas.pydata.org/pandas-docs/stable/timeseries.html| Property | Description ||----------|------------|| **`.year`** | - The year of the datetime || **`.month`** | - The month of the datetime || **`.day`** | - The days of the datetime || **`.hour`** | - The hour of the datetime || **`.minute`** | - The minutes of the datetime || **`.second`** | - The seconds of the datetime || **`.microsecond`** | - The microseconds of the datetime || **`.nanosecond`** | - The nanoseconds of the datetime || **`.date`** | - Returns datetime.date (does not contain timezone information) || **`.time`** | - Returns datetime.time (does not contain timezone information) || **`.dayofyear`** | - The ordinal day of year || **`.weekofyear`** | - The week ordinal of the year || **`.week`** | - The week ordinal of the year || **`.dayofweek`** | - The number of the day of the week with Monday=0, Sunday=6 || **`.weekday`** | - The number of the day of the week with Monday=0, Sunday=6 || **`.weekday_name`** | - The name of the day in a week (ex: Friday) || **`.quarter`** | - Quarter of the date: Jan-Mar = 1, Apr-Jun = 2, etc. || **`.days_in_month`** | - The number of days in the month of the datetime || **`.is_month_start`** | - Logical indicating if first day of month (defined by frequency) || **`.is_month_end`** | - Logical indicating if last day of month (defined by frequency) || **`.is_quarter_start`** | - Logical indicating if first day of quarter (defined by frequency) || **`.is_quarter_end`** | - Logical indicating if last day of quarter (defined by frequency) || **`.is_year_start`** | - Logical indicating if first day of year (defined by frequency) || **`.is_year_end`** | - Logical indicating if last day of year (defined by frequency) || **`.is_leap_year`** | - Logical indicating if the date belongs to a leap year | Das funktioniert dann ganz einfach:<jupyter_code>my_date.year
my_date.day
my_date.is_month_start<jupyter_output><empty_output><jupyter_text>**Quiz**:<jupyter_code># In welcher Jahreswoche liegt unser Datum `my_date`?
my_date.weekofyear

# Um was für einen Wochentag handelt es sich (Zahl)?
my_date.dayofweek<jupyter_output><empty_output><jupyter_text>Zeitintervalle "Timedelta" ist ein spezieller Datentyp, der kein Datum, sondern einen Zeitintervall modelliert.Wir können diesen Datentyp z.B. für Vergleiche zwischen zwei Daten brauchen.  Die folgenden Intervalle stehen uns dabei zur Verfügung:**`weeks`** - Wochen**`days`** - Tage**`hours`** - Stunden**`minutes`** - Minuten**`seconds`** - Sekunden**`microseconds`** - Mikrosekunden Ein Intervall erstellen wir mit der Funktion `timedelta()`<jupyter_code>d = timedelta(days=2)
d
d = timedelta(hours=1)
d<jupyter_output><empty_output><jupyter_text>Wir können die Argumente beliebig kombinieren<jupyter_code>d = timedelta(days=3, hours=10, minutes=25, seconds=10)
d<jupyter_output><empty_output><jupyter_text>Wir können ein Zeitintervall zu einem Datetime-Objekt addieren oder subtrahieren:<jupyter_code>my_date + d
my_date - d<jupyter_output><empty_output><jupyter_text>Ein Timedelta erhalten wir auch, wenn wir die Differenz von zwei Daten bilden:<jupyter_code>my_date_1 = pd.to_datetime('1981-08-23', format='%Y-%m-%d')
my_date_2 = pd.to_datetime('1981-08-25', format='%Y-%m-%d')
d = my_date_2 - my_date_1
d<jupyter_output><empty_output><jupyter_text>Die Info erhalten wir wiederum, indem wir die Eigenschaft abfragen:<jupyter_code>d.days<jupyter_output><empty_output><jupyter_text>**Quiz:** Wie viele Tage liegen zwischen folgenden Daten?<jupyter_code>my_string_1 = '2001/09/11'
my_string_2 = '2016/11/09'
#Antwort
my_date_1 = pd.to_datetime(my_string_1, format='%Y/%m/%d')
my_date_2 = pd.to_datetime(my_string_2, format='%Y/%m/%d')
d = my_date_2 - my_date_1
d.days<jupyter_output><empty_output><jupyter_text>**Quiz:** Ich werde ab dem 1. Januar 2019 um 0:00 Uhr während 685648 Sekunden keinen Alkohol trinken. An welchem Datum greife ich wieder zum Glas?<jupyter_code>#Antwort

#Startdatum als Variable kreieren
neujahr= pd.to_datetime("2019-01-01", format="%Y-%m-%d")
#Timedelta kreieren
d= timedelta(seconds=685648)

#Variable für Datum und Timedelta erstellen
trinkstart = neujahr + d

#Resultat ausgeben als String
trinkstart.strftime(format="%Y-%m-%d")<jupyter_output><empty_output><jupyter_text>Hier und Jetzt Last but not least: eine Funktion, die uns das aktuelle Datum samt Zeit angibt:<jupyter_code>jetzt = datetime.today()
jetzt<jupyter_output><empty_output><jupyter_text>Wir können dieses Datum wie jedes andere Datum auch anzeigen:<jupyter_code>jetzt.strftime(format='%Y-%m-%d: %H:%M:%S')<jupyter_output><empty_output><jupyter_text>Wir können auch damit herumrechnen:<jupyter_code>d = timedelta(days=1)
(jetzt - d).strftime(format='%Y-%m-%d: %H:%M:%S')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.16112101406219054, 'fraction_numerical': 0.031095266389384035, 'mean_word_length': 5.351572327044025, 'pattern_counts': {'":': 0, '<': 81, '<?xml version=': 0, '>': 81, 'https://': 1, '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': '20', 'dir': 'jupyter-structured-clean-dedup', 'id': '5369', 'license': 'MIT', 'n_tokens_mistral': 3865, 'n_tokens_neox': 3626, 'n_words': 1054, 'path': 'Vertiefungstage1_2/11 Pandas Teil 3/Date+Time Basics.ipynb', 'repo_name': 'Priskawa/kurstag2', 'size': '10098'}