Jakiego modułu / metody użyto do uzyskania aktualnego czasu?

Posługiwać się:

>>> import datetime
>>> datetime.datetime.now()
datetime.datetime(2009, 1, 6, 15, 8, 24, 78915)

>>> print(datetime.datetime.now())
2009-01-06 15:08:24.789150

I tylko czas:

>>> datetime.datetime.now().time()
datetime.time(15, 8, 24, 78915)

>>> print(datetime.datetime.now().time())
15:08:24.789150

Więcej informacji znajduje się w dokumentacji .

Aby zapisać pisanie, możesz zaimportować datetimeobiekt z datetimemodułu:

>>> from datetime import datetime

Następnie usuń prowadzenie datetime.ze wszystkich powyższych.

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 dane wyjściowe będą wyglądać następująco: '2013-09-18 11:16:32'

Oto lista strftimedyrektyw .

Podobne do odpowiedzi Harleya , ale użyj tej str()funkcji do szybkiego i 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?

timemoduł

timeModuł udostępnia funkcje, które mówi nam czas w sekundach od „epoki”, a także innych obiektów użyteczności publicznej.

import time

Czas epoki uniksowej

Jest to format, w którym powinieneś otrzymywać znaczniki czasu do zapisywania w bazach danych. Jest to prosta liczba zmiennoprzecinkowa, którą można przekonwertować na liczbę całkowitą. Przydaje się również do arytmetyki w sekundach, ponieważ reprezentuje liczbę sekund od 1 stycznia 1970 r. 00:00:00, i jest światłem pamięci w stosunku do innych reprezentacji czasu, na które będziemy patrzeć w następnej kolejności:

>>> time.time()
1424233311.771502

Ten znacznik czasu nie uwzględnia sekund przestępnych, więc nie jest liniowy - sekundy przestępne są ignorowane. Chociaż nie jest to równoważne z międzynarodowym standardem UTC, jest bliskie, a zatem całkiem dobre w większości przypadków prowadzenia dokumentacji.

Nie jest to jednak idealne do planowania przez ludzi. Jeśli masz przyszłe zdarzenie, które ma się odbyć w określonym momencie, będziesz chciał zapisać ten czas za pomocą ciągu, który można przeanalizować w obiekcie datetime lub w serializowanym obiekcie datetime (zostaną one opisane później).

time.ctime

Możesz również reprezentować aktualny czas w sposób preferowany przez system operacyjny (co oznacza, że ​​może on ulec zmianie po zmianie preferencji systemowych, więc nie polegaj na tym, że jest to standard we wszystkich systemach, jak zauważyłem inni) . Jest to zazwyczaj przyjazne dla użytkownika, ale zwykle nie powoduje ciągów, które można sortować chronologicznie:

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

Możesz nawodnić znaczniki czasu do postaci czytelnej dla człowieka, używając ctimerównież:

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

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

datetime moduł

datetimeModuł jest również bardzo przydatne tutaj:

>>> import datetime

datetime.datetime.now

Jest datetime.nowto metoda klasowa, która zwraca bieżący czas. Wykorzystuje informacje o time.localtimestrefie czasowej bez (jeśli nie podano, w przeciwnym razie zobacz strefę czasową świadomą poniżej). Ma reprezentację (która umożliwiłaby odtworzenie równoważnego obiektu) echo na powłoce, ale po wydrukowaniu (lub przymuszeniu do a str) jest w formacie czytelnym dla człowieka (i prawie ISO), a sortowanie leksykograficzne jest równoważne sortowanie chronologiczne:

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

datetime utcnow

Możesz uzyskać obiekt datetime w czasie UTC, globalnym standardzie, wykonując następujące czynności:

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

UTC jest standardem czasowym, który jest prawie równoważny strefie czasowej GMT. (Chociaż GMT i UTC nie zmieniają się dla czasu letniego, ich użytkownicy mogą przełączać się na inne strefy czasowe, takie jak brytyjski czas letni).

rozpoznanie strefy czasowej datetime

Jednak żaden z dotychczas utworzonych obiektów datetime nie może być łatwo przekonwertowany na różne strefy czasowe. Możemy rozwiązać ten problem z pytzmodułem:

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

Odpowiednio w Pythonie 3 mamy timezoneklasę z timezonedołączoną instancją utc , co powoduje, że obiektowa strefa czasowa jest świadoma (ale konwersję do innej strefy czasowej bez przydatnego pytzmodułu pozostawia się jako ćwiczenie dla czytelnika):

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

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 także uświadomić naiwny obiekt daty / godziny za pomocą metody pytztimezone localizelub zastępując atrybut tzinfo (z replace, odbywa się to na ślepo), ale są to bardziej ostateczności 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>)

pytzModuł pozwala nam, aby nasze datetimeobiekty stref czasowych świadomy i konwertować razy do setek stref czasowych dostępnych w pytzmodule.

Można pozornie serializacji ten obiekt dla UTC czasu i sklepu , że w bazie danych, ale wymagałoby to znacznie więcej pamięci i jest bardziej podatne na błędy niż tylko przechowywanie czas uniksowy epoka, którą wykazano w pierwszej kolejności.

Inne sposoby wyświetlania czasu są znacznie bardziej podatne na błędy, szczególnie w przypadku danych, które mogą pochodzić z różnych stref czasowych. Chcesz, aby nie było nieporozumień co do tego, dla której strefy czasowej jest przeznaczony ciąg lub szeregowany obiekt daty / godziny.

Jeśli wyświetlasz czas w Pythonie dla użytkownika, ctimedziała dobrze, nie w tabeli (zwykle nie sortuje się dobrze), ale może w zegarze. Jednak osobiście polecam, gdy mam do czynienia z czasem w Pythonie, albo używając czasu uniksowego, albo datetimeobiektu UTC obsługującego strefę czasową .

Zrobić

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'

To generuje bieżący GMT w określonym formacie. Jest też localtime()metoda.

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

Wszystkie poprzednie odpowiedzi są dobrymi sugestiami, ale uważam, że jest najłatwiejszy w użyciu ctime():

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

Daje to dobrze sformatowany ciąg znaków reprezentujący bieżący czas lokalny.

Najszybszym sposobem jest:

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

Jeśli potrzebujesz aktualnego czasu jako timeobiektu:

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

.isoformat() znajduje się w dokumentacji, ale jeszcze jej nie ma (jest to bardzo podobne do odpowiedzi @Ray Vega):

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

Dlaczego nie zapytać US Naval Observatory , oficjalnego sędziego mierzącego czas w marynarce 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])

Jeśli mieszkasz w obszarze DC (jak ja), opóźnienie może nie być takie złe ...

Korzystanie z pand, aby uzyskać aktualny czas, rodzaj przesady problemu:

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)

Wynik:

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

Właśnie z tym skończyłem:

>>>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 data została sformatowana dokładnie tak, jak chcesz (z dokumentacji Pythona „datetime” tutaj ).

jeśli używasz już numpy, możesz bezpośrednio użyć funkcji numpy.datetime64 ().

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

tylko na datę:

str(np.datetime64('today'))

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

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

lub,

str(pd.to_datetime('today'))

Możesz użyć timemodułu:

import time
print time.strftime("%d/%m/%Y")

>>> 06/02/2015

Wykorzystanie kapitału Ydaje cały rok, a wykorzystanie ydałoby 06/02/15.

Możesz również użyć następującego kodu, aby wydłużyć czas:

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

datetime.now()zwraca bieżący czas jako naiwny obiekt typu data-godzina reprezentujący czas w lokalnej strefie czasowej. Ta wartość może być niejednoznaczna, np. Podczas przejść DST („cofanie się”). Aby uniknąć dwuznaczności, należy użyć dowolnej strefy czasowej UTC:

from datetime import datetime

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

Lub obiekt obsługujący strefę czasową, do którego dołączone są 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 dowolne zmienne, w tym pakiet. 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 now()funkcja zwraca dane wyjściowe w YYYY-MM-DD HH:MM:SS:MSformacie. Użyj poniższego przykładowego skryptu, aby uzyskać bieżącą datę i godzinę w skrypcie Python i wydrukować wyniki na ekranie. Utwórz plik getDateTime1.pyz poniższą zawartością.

import datetime

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

Dane wyjściowe wyglądają jak poniżej:

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 uzasadnieniem. Jest to biblioteka Pendulum , która wydaje się robić rzeczy, które próbowała strzała, chyba że bez nieodłącznych wad i błędów, które nękają strzałę.

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ą rozwiązania, w tym wiele RFC i ISO, aby się martwić. Kiedyś je pomieszać; nie martw się, rzuć okiem na. dir(pendulum.constants)Jest tam jednak coś więcej niż formaty RFC i ISO.

Kiedy mówimy lokalnie, co mamy na myśli? Mam na myśli:

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

Prawdopodobnie większość z was ma na myśli coś innego.

I to idzie. Krótko mówiąc: Wahadło próbuje ustalić datę i godzinę tego, co zrobiły żądania HTTP. Warto to rozważyć, szczególnie ze względu na łatwość użycia i obszerną dokumentację.

Aktualny czas 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ł strzałki ze strony http://crsmithdev.com/arrow/ :

import arrow
arrow.now()

Lub wersja UTC:

arrow.utcnow()

Aby zmienić wynik, 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ę uzyskać czas w milisekundach. 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

Ale chcę tylko milisekund , prawda? Najkrótszy sposób na ich zdobycie:

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ę miejsc po przecinku, 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)

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 uzyskać godziny, minuty, sekundy i milisekundy do scalenia później, 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]

Druga:

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]

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))

Oto, czego używam, aby uzyskać czas bez konieczności formatowania. Niektórym nie podoba się metoda podziału, ale przydaje się tutaj:

from time import ctime
print ctime().split()[3]

Zostanie wydrukowany w formacie GG: MM: SS.

Ponieważ nikt jeszcze o tym nie wspominał, a ostatnio natrafiłem na to ... metoda fromutc () pytz timezone w połączeniu z utcnow () datetime to najlepszy sposób, w jaki udało mi się 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 wszystko, czego chcesz, to czas, 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 dla Pythona, ważne jest, aby pamiętać, że jeśli używasz Django, zawsze możesz użyć timezone.now()zamiast niego datetime.datetime.now(). Pierwsza jest „świadoma” strefy czasowej, a druga nie.

Zobacz tę odpowiedź SO i dokument Django, aby uzyskać szczegółowe informacje i uzasadnienie timezone.now().

from django.utils import timezone

now = timezone.now()

Możesz to zrobić za pomocą ctime ():

from time import time, ctime
t = time()
ctime(t)

wynik:

Sat Sep 14 21:27:08 2019

Te dane wyjściowe są różne, ponieważ zwracany znacznik czasu ctime()zależy od położenia geograficznego.