Możesz użyć time.strftime():

>>> from time import gmtime, strftime
>>> strftime("%Y-%m-%d %H:%M:%S", gmtime())
'2009-01-05 22:14:39'

from datetime import datetime
datetime.now().strftime('%Y-%m-%d %H:%M:%S')

W tym przykładzie wynik będzie wyglądał następująco: '2013-09-18 11:16:32'

Oto lista strftime dyrektywy .

Podobne do odpowiedzi Harleya , ale użyj funkcji str() dla szybkiego-N-brudnego, nieco bardziej czytelnego dla człowieka formatu:

>>> from datetime import datetime
>>> str(datetime.now())
'2011-05-03 17:45:35.177000'

Jak uzyskać aktualny czas w Pythonie?

Moduł time

Moduł time zapewnia funkcje, które mówią nam czas w "sekundach od epoki", jak również inne narzędzia.

import time

Unix Epoch Time

Jest to format, w którym powinny być zapisywane znaczniki czasu w bazach danych. Jest to prosta Liczba zmiennoprzecinkowa, którą można przekształcić na liczbę całkowitą. Jest również dobry do arytmetyki w sekundach, ponieważ reprezentuje liczbę sekund od stycznia 1, 1970, 00:00:00, i jest to światło pamięci w stosunku do innych reprezentacji Czasu, które będziemy oglądać dalej: {]}

>>> time.time()
1424233311.771502

Ten znacznik czasu nie uwzględnia sekund przestępnych, więc nie jest liniowy - sekundy przestępne są ignorowane. Tak więc, chociaż nie jest to odpowiednik międzynarodowego standardu UTC, jest blisko, a zatem całkiem dobre dla większości przypadków prowadzenia dokumentacji.

Nie jest to jednak idealne dla ludzkiego planowania. Jeśli masz jakieś przyszłe wydarzenie, które chcesz odbyć w w pewnym momencie będziesz chciał zapisać ten czas za pomocą ciągu znaków, który można przetworzyć do obiektu datetime lub obiektu serializowanego datetime (zostaną one opisane później).

time.ctime

Możesz również reprezentować bieżący czas w sposób preferowany przez Twój system operacyjny (co oznacza, że może się zmienić po zmianie Preferencji systemowych, więc nie polegaj na tym, aby był to standard we wszystkich systemach, jak widziałem inni oczekują). Jest to zazwyczaj przyjazne dla użytkownika, ale zazwyczaj nie wynik w łańcuchach można sortować chronologicznie:

>>> time.ctime()
'Tue Feb 17 23:21:56 2015'

Można również uwodnić znaczniki czasu do postaci czytelnej dla człowieka za pomocą ctime:

>>> time.ctime(1424233311.771502)
'Tue Feb 17 23:21:51 2015'

Ta konwersja nie jest również dobra do przechowywania dokumentacji (z wyjątkiem tekstu, który będzie analizowany tylko przez ludzi - a przy ulepszonym rozpoznawaniu znaków optycznych i sztucznej inteligencji, myślę, że liczba tych przypadków zmniejszy się).

datetime moduł

Moduł datetime jest również bardzo przydatny tutaj:

>>> import datetime

datetime.datetime.now

{[20] } jest metodą klasy, która zwraca bieżący czas. Używa time.localtime BEZ informacji o strefie czasowej (jeśli nie podano, w przeciwnym razie patrz Strefa czasowa aware poniżej). W przeciwieństwie do innych obiektów, które nie są w stanie odtworzyć obiektu, nie są one w stanie odtworzyć obiektu, ale są w stanie odtworzyć obiekt w formacie ISO, co jest równoznaczne z sortowaniem chronologicznym: str]}

>>> datetime.datetime.now()
datetime.datetime(2015, 2, 17, 23, 43, 49, 94252)
>>> print(datetime.datetime.now())
2015-02-17 23:43:51.782461

Datetime ' s utcnow

>>> datetime.datetime.utcnow()
datetime.datetime(2015, 2, 18, 4, 53, 28, 394163)
>>> print(datetime.datetime.utcnow())
2015-02-18 04:53:31.783988

DateTime timezone aware

Jednak żaden z utworzonych do tej pory obiektów datetime nie może być łatwo konwertowany do różnych stref czasowych. Możemy Rozwiąż ten problem za pomocą modułu pytz:

>>> import pytz
>>> then = datetime.datetime.now(pytz.utc)
>>> then
datetime.datetime(2015, 2, 18, 4, 55, 58, 753949, tzinfo=<UTC>)

Równoważnie, w Pythonie 3 mamy klasę timezone z dołączoną instancją utc timezone, która również uświadamia strefę czasową obiektu (ale konwersja do innej strefy czasowej bez poręcznego modułu pytz jest pozostawiona jako ćwiczenie dla czytelnika):

>>> datetime.datetime.now(datetime.timezone.utc)
datetime.datetime(2015, 2, 18, 22, 31, 56, 564191, tzinfo=datetime.timezone.utc)

I widzimy, że możemy łatwo przekonwertować na strefy czasowe z oryginalnego obiektu UTC.

>>> print(then)
2015-02-18 04:55:58.753949+00:00
>>> print(then.astimezone(pytz.timezone('US/Eastern')))
2015-02-17 23:55:58.753949-05:00

Możesz również uświadomić naiwny obiekt datetime za pomocą metody pytz Strefa czasowa localize, można też zastąpić atrybut tzinfo (przez replace, robi się to ślepo), ale są to bardziej Ostatnie Kurorty niż najlepsze praktyki:

>>> pytz.utc.localize(datetime.datetime.utcnow())
datetime.datetime(2015, 2, 18, 6, 6, 29, 32285, tzinfo=<UTC>)
>>> datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
datetime.datetime(2015, 2, 18, 6, 9, 30, 728550, tzinfo=<UTC>)

Moduł pytz pozwala nam uświadomić strefę czasową naszych obiektów datetime i przekonwertować czasy na setki stref czasowych dostępnych w module pytz.

Można pozornie serializować ten obiekt dla czasu UTC i przechowywać to w bazie danych, ale wymagałoby to znacznie więcej pamięci i byłoby bardziej podatne na błędy niż zwykłe przechowywanie Unix Epoch time, który zademonstrowałem jako pierwszy.

Inne sposoby wyświetlania czasów są znacznie bardziej podatne na błędy, zwłaszcza w przypadku danych, które mogą pochodzić z różnych stref czasowych. Chcesz, aby nie było nieporozumień co do strefy czasowej, dla której przeznaczony był łańcuch lub serializowany obiekt datetime.

Jeśli wyświetlasz czas w Pythonie dla użytkownika, ctime działa ładnie, Nie w tabeli( zazwyczaj nie sortuje się dobrze), ale być może w zegarze. Jednak osobiście polecam, gdy mamy do czynienia z czasem w Pythonie, korzystamy z uniksowego czasu lub z obiektu UTC datetime.

Do

from time import time

t = time()

• t - Liczba zmiennoprzecinkowa, dobra do pomiaru przedziału czasu.

Istnieje pewna różnica dla platform Unix i Windows.

>>> from time import gmtime, strftime
>>> strftime("%a, %d %b %Y %X +0000", gmtime())
'Tue, 06 Jan 2009 04:54:56 +0000'

, który wyświetla bieżący GMT w określonym formacie. Istnieje również localtime() metoda.

Ta strona zawiera więcej szczegółów.

Poprzednie odpowiedzi są dobrymi sugestiami, ale uważam, że najłatwiej jest użyć ctime():

In [2]: from time import ctime
In [3]: ctime()
Out[3]: 'Thu Oct 31 11:40:53 2013'

To daje ładnie sformatowaną reprezentację ciągu bieżącego czasu lokalnego.

Najszybszy sposób to:

>>> import time
>>> time.strftime("%Y%m%d")
'20130924'

Jeśli potrzebujesz bieżącego czasu jako obiektu time:

>>> import datetime
>>> now = datetime.datetime.now()
>>> datetime.time(now.hour, now.minute, now.second)
datetime.time(11, 23, 44)

.isoformat() jest w dokumentacji, ale jeszcze nie tutaj (to jest bardzo podobne do odpowiedzi @ Ray Vega):

>>> import datetime
>>> datetime.datetime.now().isoformat()
'2013-06-24T20:35:55.982000'

Dlaczego nie zapytasz U. S. Naval Observatory, oficjalnego strażnika czasu Marynarki Wojennej Stanów Zjednoczonych?

import requests
from lxml import html

page = requests.get('http://tycho.usno.navy.mil/cgi-bin/timer.pl')
tree = html.fromstring(page.content)
print(tree.xpath('//html//body//h3//pre/text()')[1])

Użycie pandas , Aby uzyskać aktualny czas, trochę przesadnie problem pod ręką:

import pandas as pd
print(pd.datetime.now())
print(pd.datetime.now().date())
print(pd.datetime.now().year)
print(pd.datetime.now().month)
print(pd.datetime.now().day)
print(pd.datetime.now().hour)
print(pd.datetime.now().minute)
print(pd.datetime.now().second)
print(pd.datetime.now().microsecond)

Wyjście:

2017-09-22 12:44:56.092642
2017-09-22
2017
9
22
12
44
56
92693

Możesz użyć modułu time:

>>> import time
>>> print(time.strftime("%d/%m/%Y"))
06/02/2015

Użycie kapitału Y daje pełny rok, a użycie {[4] } daje 06/02/15.

Możesz również użyć poniższego kodu, aby dać dłuższy czas:

>>> time.strftime("%a, %d %b %Y %H:%M:%S")
'Fri, 06 Feb 2015 17:45:09'

Tak się skończyło:

>>>from time import strftime
>>>strftime("%m/%d/%Y %H:%M")
01/09/2015 13:11

Ponadto, ta tabela jest niezbędnym odniesieniem do wyboru odpowiednich kodów formatu, aby uzyskać datę sformatowaną tak, jak chcesz (z Dokumentacji Pythona "datetime" tutaj).

Jeśli używasz numpy już wtedy bezpośrednio możesz użyć numpy.datetime64() funkcja.

import numpy as np
str(np.datetime64('now'))

Tylko Dla daty:

str(np.datetime64('today'))

Lub, jeśli używasz już pandy, możesz użyć funkcji pandas.to_datetime ()

import pandas as pd
str(pd.to_datetime('now'))

Lub

str(pd.to_datetime('today'))

datetime.now() zwraca bieżący czas jako naiwny obiekt datetime, który reprezentuje czas w lokalnej strefie czasowej. Wartość ta może być niejednoznaczna np. podczas przejść DST ("fall back"). Aby uniknąć niejednoznaczności należy użyć strefy czasowej UTC:

from datetime import datetime

utc_time = datetime.utcnow()
print(utc_time) # -> 2014-12-22 22:48:59.916417

Lub obiekt świadomy strefy czasowej, który ma dołączone odpowiednie informacje o strefie czasowej (Python 3.2+):

from datetime import datetime, timezone

now = datetime.now(timezone.utc).astimezone()
print(now) # -> 2014-12-23 01:49:25.837541+03:00

import datetime
date_time = datetime.datetime.now()

date = date_time.date()  # Gives the date
time = date_time.time()  # Gives the time

print date.year, date.month, date.day
print time.hour, time.minute, time.second, time.microsecond

Do dir(date) lub dowolnych zmiennych łącznie z pakietem. Możesz uzyskać wszystkie atrybuty i metody powiązane ze zmienną.

>>> import datetime, time
>>> time = time.strftime("%H:%M:%S:%MS", time.localtime())
>>> print time
'00:21:38:20S'

Domyślnie funkcja now() zwraca wyjście w formacie YYYY-MM-DD HH:MM:SS:MS. Użyj poniższego przykładowego skryptu, aby pobrać aktualną datę i godzinę w skrypcie Pythona i wydrukować wyniki na ekranie. Utwórz plik getDateTime1.py z poniższą zawartością.

import datetime

currentDT = datetime.datetime.now()
print (str(currentDT))

Wyjście wygląda następująco:

2018-03-01 17:03:46.759624

To pytanie nie potrzebuje nowej odpowiedzi, tylko ze względu na to ... błyszcząca nowa zabawka / moduł jest jednak wystarczającym usprawiedliwieniem. To jest Pendulum library , która wydaje się robić rzeczy, które arrow próbował, z wyjątkiem nieodłącznych wad i błędów, które nękają Arrowa.

Na przykład odpowiedź na pierwotne pytanie:

>>> import pendulum
>>> print(pendulum.now())
2018-08-14T05:29:28.315802+10:00
>>> print(pendulum.now('utc'))
2018-08-13T19:29:35.051023+00:00

Istnieje wiele standardów, które wymagają adresacji, w tym wiele RFC i ISOs, o które należy się martwić. Ever get nie martw się, przyjrzyj się dir(pendulum.constants) jest tam jednak trochę więcej niż formaty RFC i ISO.

>>> print(pendulum.now().timezone_name)
Australia/Melbourne
>>>

Czas bieżący strefy czasowej

from datetime import datetime
import pytz

tz_NY = pytz.timezone('America/New_York') 
datetime_NY = datetime.now(tz_NY)
print("NY time:", datetime_NY.strftime("%H:%M:%S"))

tz_London = pytz.timezone('Europe/London')
datetime_London = datetime.now(tz_London)
print("London time:", datetime_London.strftime("%H:%M:%S"))

tz_India = pytz.timezone('Asia/India')
datetime_India = datetime.now(tz_India)
print("India time:", datetime_India.strftime("%H:%M:%S"))

#list timezones
pytz.all_timezones

Wypróbuj moduł arrow z http://crsmithdev.com/arrow/:

import arrow
arrow.now()

Lub wersja UTC:

arrow.utcnow()

Aby zmienić wyjście, dodaj .format ():

arrow.utcnow().format('YYYY-MM-DD HH:mm:ss ZZ')

Dla określonej strefy czasowej:

arrow.now('US/Pacific')

Godzinę temu:

arrow.utcnow().replace(hours=-1)

Lub jeśli chcesz sedno.

arrow.get('2013-05-11T21:23:58.970460+00:00').humanize()
>>> '2 years ago'

Chcę mieć czas z milisekundami. Prosty sposób na ich zdobycie:

import time, datetime

print(datetime.datetime.now().time())                         # 11:20:08.272239

# Or in a more complicated way
print(datetime.datetime.now().time().isoformat())             # 11:20:08.272239
print(datetime.datetime.now().time().strftime('%H:%M:%S.%f')) # 11:20:08.272239

# But do not use this:
print(time.strftime("%H:%M:%S.%f", time.localtime()), str)    # 11:20:08.%f

import time

time.strftime("%H:%M:%S", time.localtime()) + '.%d' % (time.time() % 1 * 1000)
# 11:34:23.751

Dodaj lub usuń zera z ostatniego mnożenia, aby dostosować liczbę punktów dziesiętnych, lub po prostu:

def get_time_str(decimal_points=3):
    return time.strftime("%H:%M:%S", time.localtime()) + '.%d' % (time.time() % 1 * 10**decimal_points)

Jeśli chcesz tylko bieżący znacznik czasu w ms( na przykład do pomiaru czasu wykonania), możesz również użyć modułu "timeit":

import timeit
start_time = timeit.default_timer()
do_stuff_you_want_to_measure()
end_time = timeit.default_timer()
print("Elapsed time: {}".format(end_time - start_time))

Możesz użyć tej funkcji, aby uzyskać czas (niestety nie mówi AM lub PM):

def gettime():
    from datetime import datetime
    return ((str(datetime.now())).split(' ')[1]).split('.')[0]

Aby później połączyć godziny, minuty, sekundy i milisekundy, możesz użyć następujących funkcji:

godzina:

def gethour():
    from datetime import datetime
    return (((str(datetime.now())).split(' ')[1]).split('.')[0]).split(':')[0]

minuta:

def getminute():
    from datetime import datetime
    return (((str(datetime.now())).split(' ')[1]).split('.')[0]).split(':')[1]

drugi:

def getsecond():
    from datetime import datetime
    return (((str(datetime.now())).split(' ')[1]).split('.')[0]).split(':')[2]

milisekunda:

def getmillisecond():
    from datetime import datetime
    return (str(datetime.now())).split('.')[1]

import datetime

todays_date = datetime.date.today()
print(todays_date)
>>> 2019-10-12

# adding strftime will remove the seconds
current_time = datetime.datetime.now().strftime('%H:%M')
print(current_time)
>>> 23:38

Możesz wypróbować następujące

import datetime

now = datetime.datetime.now()
print(now)

Lub

import datetime

now = datetime.datetime.now()
print(now.strftime("%Y-%b-%d, %A %I:%M:%S"))

Ponieważ nikt jeszcze o tym nie wspomniał, a to jest coś, na co ostatnio wpadłem... metoda fromutc () pytz timezone w połączeniu z utcnow () datetime jest najlepszym sposobem, jaki znalazłem, aby uzyskać użyteczny bieżący czas (i datę) w dowolnej strefie czasowej.

from datetime import datetime

import pytz


JST = pytz.timezone("Asia/Tokyo")


local_time = JST.fromutc(datetime.utcnow())

Jeśli chcesz tylko czasu, możesz to uzyskać za pomocą local_time.time().

To pytanie dotyczy Pythona, ale ponieważ Django jest jednym z najczęściej używanych frameworków Pythona, ważne jest, aby pamiętać, że jeśli używasz Django, zawsze możesz użyć timezone.now() zamiast datetime.datetime.now(). Pierwsza jest strefą czasową "świadomą", podczas gdy druga nie.

Zobacz this so answer oraz Django doc Po szczegóły i uzasadnienie timezone.now().

from django.utils import timezone

now = timezone.now()