Converteren van datums en tijden naar en van strings in Python datetime (strftime, strptime)

Bedrijf

Python's standaard bibliotheek datetime kan gebruikt worden om datums en tijden (datums, tijden en tijden) te verwerken. De methoden strftime() en strptime(), die datums en tijden converteren naar en van strings, kunnen worden gebruikt om datums en tijden in een verscheidenheid van formaten te manipuleren.

Het kan ook bewerkingen uitvoeren zoals aftrekken en optellen. U kunt bijvoorbeeld gemakkelijk de datum van 10 dagen geleden berekenen of die van over 3 weken, of de tijd over 50 minuten.

Eerst zullen we de volgende klassen van objecten beschrijven die beschikbaar zijn in de datetime module.

  • datetime.datetime:Date and time (datum en tijd)
  • datetime.date:Datum
  • datetime.time:Tijd
  • datetime.timedelta:Tijdsverschil en verstreken tijd

De methoden strftime() en strptime(), die datum en string naar elkaar omzetten, worden ook uitgelegd.

  • datetimeobject
    • datetime.now():De datum van vandaag, de huidige tijd
    • datetimeObject Constructor
    • Omzetten van een datetime object naar een datum object
  • dateobject
    • date.today():De datum van vandaag
    • Constructor voor het datumobject
  • timeobject
    • Constructor voor het tijd object
  • timedeltaobject
    • Trek datetime en datum objecten af om timedelta objecten te maken.
    • Constructor voor het timedelta object
    • Aftrekken en optellen met timedelta-objecten
  • strftime():Conversie van datum en tijd naar string
  • strptime():Conversie van string naar datum en tijd

In de standaardbibliotheek is ook de kalendermodule opgenomen, die kalenders genereert in platte tekst of HTML-formaat.

datetime-object

Een datetime object is een object dat zowel datum (jaar, maand, dag) als tijd (uur, minuut, seconde, microseconde) informatie bevat. Je kunt die informatie benaderen met de volgende attributen.

  • year
  • month
  • day
  • hour
  • minute
  • second
  • microsecond

datetime.now(): De datum van vandaag, de huidige tijd

datetime.now() zal je een datetime object geven met de datum van vandaag (de huidige datum) en de huidige tijd.

import datetime

dt_now = datetime.datetime.now()
print(dt_now)
# 2018-02-02 18:31:13.271231

print(type(dt_now))
# <class 'datetime.datetime'>

print(dt_now.year)
# 2018

print(dt_now.hour)
# 18

Constructor voor datetime object

Het is ook mogelijk om datetime objecten te genereren voor willekeurige data en tijden.

De constructor voor het datetime object is als volgt.

datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

De volgende waarden zijn verplicht; andere waarden kunnen worden weggelaten. Indien weggelaten, is de standaardwaarde 0.

  • year
  • month
  • day
dt = datetime.datetime(2018, 2, 1, 12, 15, 30, 2000)
print(dt)
# 2018-02-01 12:15:30.002000

print(dt.minute)
# 15

print(dt.microsecond)
# 2000

dt = datetime.datetime(2018, 2, 1)
print(dt)
# 2018-02-01 00:00:00

print(dt.minute)
# 0

Omzetten van een datetime object naar een datum object

Een datetime object kan geconverteerd worden naar een datum object met de date() methode, zoals hierna beschreven.

print(dt_now)
print(type(dt_now))
# 2018-02-02 18:31:13.271231
# <class 'datetime.datetime'>

print(dt_now.date())
print(type(dt_now.date()))
# 2018-02-02
# <class 'datetime.date'>

datumobject

Een datumobject is een object dat informatie bevat over een datum (jaar, maand, dag). Het kan benaderd worden met de attributen jaar, maand en dag.

date.today(): De datum van vandaag

Het datumobject van de huidige datum (de datum van vandaag) kan worden verkregen met date.today().

d_today = datetime.date.today()
print(d_today)
# 2018-02-02

print(type(d_today))
# <class 'datetime.date'>

print(d_today.year)
# 2018

Constructor voor het datumobject

De constructor voor het datumobject is als volgt

date(year, month, day)

Ze zijn allemaal verplicht en kunnen niet worden weggelaten.

d = datetime.date(2018, 2, 1)
print(d)
# 2018-02-01

print(d.month)
# 2

tijdsobject

Het tijdobject is een object dat informatie bevat over de tijd (uren, minuten, seconden en microseconden). Het kan worden benaderd met behulp van de attributen uur, minuut, seconde, en microseconde.

Constructor voor het tijd object

De constructor van het tijdobject is als volgt.

time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

Ze zijn allemaal optioneel, en als ze worden weggelaten, worden ze op 0 gezet.

t = datetime.time(12, 15, 30, 2000)
print(t)
# 12:15:30.002000

print(type(t))
# <class 'datetime.time'>

print(t.hour)
# 12

t = datetime.time()
print(t)
# 00:00:00

timedelta-object

Het timedelta-object is een object dat het tijdsverschil tussen twee datums en tijden weergeeft, of de verstreken tijd. Het heeft informatie in dagen, seconden en microseconden, en kan benaderd worden met de attributen dagen, seconden en microseconden. Het is ook mogelijk om het totaal aantal seconden te verkrijgen met de methode total_seconds().

Trek datetime en datum objecten af om een timedelta object te maken.

Het van elkaar aftrekken van datetime-objecten levert een timedelta-object op.

td = dt_now - dt
print(td)
# 1 day, 18:31:13.271231

print(type(td))
# <class 'datetime.timedelta'>

print(td.days)
# 1

print(td.seconds)
# 66673

print(td.microseconds)
# 271231

print(td.total_seconds())
# 153073.271231

Het van elkaar aftrekken van datumobjecten levert op vergelijkbare wijze een timedelta-object op.

Constructor voor het timedelta object

De constructor van het timedelta-object is als volgt

timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

Ze zijn allemaal optioneel, en als ze worden weggelaten, worden ze op 0 gezet.

Merk op dat het timedelta-object alleen de volgende informatie bevat.

  • een aantal dagen: days
  • aantal seconden: seconds
  • microseconden telling: microseconds

Bijvoorbeeld, de volgende twee zijn gelijk

  • weeks=1
  • days=7
td_1w = datetime.timedelta(weeks=1)
print(td_1w)
# 7 days, 0:00:00

print(td_1w.days)
# 7

Aftrekken en optellen met timedelta-objecten

Het timedelta object kan gebruikt worden met de datetime en date objecten om bewerkingen uit te voeren zoals aftrekken en optellen. Zo kunt u bijvoorbeeld gemakkelijk de datum van een week geleden of over 10 dagen berekenen en krijgen, of de tijd over 50 minuten.

d_1w = d_today - td_1w
print(d_1w)
# 2018-01-26

td_10d = datetime.timedelta(days=10)
print(td_10d)
# 10 days, 0:00:00

dt_10d = dt_now + td_10d
print(dt_10d)
# 2018-02-12 18:31:13.271231

td_50m = datetime.timedelta(minutes=50)
print(td_50m)
# 0:50:00

print(td_50m.seconds)
# 3000

dt_50m = dt_now + td_50m
print(dt_50m)
# 2018-02-02 19:21:13.271231

Het kan ook worden gebruikt om het aantal dagen tot een bepaalde datum te berekenen.

d_target = datetime.date(2020, 7, 24)
td = d_target - d_today
print(td)
# 903 days, 0:00:00

print(td.days)
# 903

strftime(): Conversie van datum en tijd naar string

De strftime() methode van datetime en date objecten kan worden gebruikt om datum en tijd (datum en tijd) informatie om te zetten in een string in elk formaat.

opmaakcode

Zie de officiële documentatie hieronder voor de beschikbare opmaakcodes.

De belangrijkste opmaakcodes staan hieronder vermeld.

  • %d:Dag van de maand in decimale notatie met nul gevuld.
  • %m:Maand in decimale notatie met nul gevuld.
  • %y:De laatste twee cijfers van het jaar in decimale notatie met nul.
  • %Y:Vier cijfers van het jaar in decimale notatie met nul gevuld.
  • %H:Wanneer uitgedrukt in decimale notatie met nul gevuld (24-uurs notatie)
  • %I:Wanneer uitgedrukt in decimale notatie met nul gevuld (12-uurs notatie)
  • %M:Voor decimale notatie met nul gevuld.
  • %S:Seconden in decimale notatie met nul gevuld.
  • %f:Microseconden (6 cijfers) in decimale notatie met 0 gevuld.
  • %A:Naam van de dag van de week voor de locale
  • %a:Naam van de dag voor de locale (afgekorte vorm)
  • %B:Locale maand naam
  • %b:Locale maand naam (afgekorte vorm)
  • %j:Dag van het jaar in decimale notatie met nulvulling.
  • %U:Weeknummer van het jaar in decimale notatie met nulvulling (de week begint op zondag)
  • %W:Weeknummer van het jaar in decimale notatie met nulvulling (de week begint op maandag)

De volgende opmaakcodes voor dag- en maandnamen kunnen worden verkregen in verschillende strings, afhankelijk van de locale.

  • %A
  • %a
  • %B
  • %b

Er is ook een speciale methode voor ISO 8601-formaat strings.

Voorbeeldcode

print(dt_now.strftime('%Y-%m-%d %H:%M:%S'))
# 2018-02-02 18:31:13

print(d_today.strftime('%y%m%d'))
# 180202

print(d_today.strftime('%A, %B %d, %Y'))
# Friday, February 02, 2018

print('Day number (how many days in a year / January 1 is 001):', d_today.strftime('%j'))
print('Week number (the week starts on Sunday / New Year's Day is 00):', d_today.strftime('%U'))
print('Week number (the week begins on Monday / New Year's Day is 00):', d_today.strftime('%W'))
# Day number (how many days in a year / January 1 is 001): 033
# Week number (the week starts on Sunday / New Year's Day is 00): 04
# Week number (the week begins on Monday / New Year's Day is 00): 05

Als je een getal wilt krijgen in plaats van een string, converteer het dan naar een geheel getal met int().

week_num_mon = int(d_today.strftime('%W'))
print(week_num_mon)
print(type(week_num_mon))
# 5
# <class 'int'>

In combinatie met het timedelta-object is het eenvoudig om bijvoorbeeld een lijst van tweewekelijkse data in elk gewenst formaat te maken.

d = datetime.date(2018, 2, 1)
td = datetime.timedelta(weeks=2)
n = 8
f = '%Y-%m-%d'

l = []

for i in range(n):
    l.append((d + i * td).strftime(f))

print(l)
# ['2018-02-01', '2018-02-15', '2018-03-01', '2018-03-15', '2018-03-29', '2018-04-12', '2018-04-26', '2018-05-10']

print('\n'.join(l))
# 2018-02-01
# 2018-02-15
# 2018-03-01
# 2018-03-15
# 2018-03-29
# 2018-04-12
# 2018-04-26
# 2018-05-10

Het gebruik van de list comprehension notatie is slimmer.

l = [(d + i * td).strftime(f) for i in range(n)]
print(l)
# ['2018-02-01', '2018-02-15', '2018-03-01', '2018-03-15', '2018-03-29', '2018-04-12', '2018-04-26', '2018-05-10']

strptime(): Conversie van string naar datum en tijd

datetime strptime() kan gebruikt worden om een datetime object te maken van een datum of tijd string. Het is noodzakelijk om de opmaak string te specificeren die overeenkomt met de originele string.

Er is ook een speciale methode voor ISO 8601 strings (Python 3.7 of hoger).

Voorbeeldcode

date_str = '2018-2-1 12:30'
date_dt = datetime.datetime.strptime(date_str, '%Y-%m-%d %H:%M')
print(date_dt)
# 2018-02-01 12:30:00

print(type(date_dt))
# <class 'datetime.datetime'>

Door gebruik te maken van de strftime() methode op het opgehaalde datetime object, kan je de datum en tijd weergeven in een ander formaat dan de originele string.

print(date_dt.strftime('%Y-%m-%d %H:%M'))
# 2018-02-01 12:30

Als je het converteert naar een datetime object, kun je ook operaties uitvoeren met timedelta objecten, zodat je bijvoorbeeld een string kunt genereren van een datum 10 dagen geleden in hetzelfde formaat.

date_str = '2018-2-1'
date_format = '%Y-%m-%d'
td_10_d = datetime.timedelta(days=10)

date_dt = datetime.datetime.strptime(date_str, date_format)
date_dt_new = date_dt - td_10_d
date_str_new = date_dt_new.strftime(date_format)

print(date_str_new)
# 2018-01-22