Poniżej tego używam, aby uzyskać czas bez konieczności formatowania. Niektórzy ludzie nie lubią metody podzielonej, ale jest przydatna tutaj:

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

Będzie drukować w formacie HH: MM: SS.

import datetime
date_time = str(datetime.datetime.now()).split()
date,time = date_time

Data Wydrukuje datę i czas , będzie wydrukowany czas.

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, wyjście będzie takie: '2013-09-18 11:16:32'

Oto lista strftime Dyrektywy .

Podobny do Odpowiedź Harleya, ale użyj {{ X0}} Funkcja dla szybkiego n-brudu, nieco więcej formatu czytelnego dla człowieka:

>>> 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", a także innych mediów.

import time

Czas EPOX UNIX.

Jest to format, który należy uzyskać znaczniki czasu do zapisywania w bazach danych. Jest to prosty numer zmiennoprzecinkowy, który można konwertować na liczbę całkowitą. Jest również dobry dla arytmetyki w kilka sekund, ponieważ reprezentuje liczbę sekund od 1 stycznia 1970 r.

>>> time.time()
1424233311.771502

Ten znacznik czasu nie uwzględnia skoków, więc nie jest to liniowe - sekundy skokowe są ignorowane. Więc chociaż nie jest równoważne międzynarodowym standardem UTC, jest blisko, a zatem całkiem dobre dla większości przypadków prowadzenia rekordów.

Nie jest to jednak idealne do holowniczego harmonogramu. Jeśli masz przyszłe wydarzenie, chcesz odbywać się w pewnym momencie, będziesz chciał przechowywać tego czasu z ciągiem, który można przenikać do obiektu datetime lub serializowanego obiektu datetime (zostaną opisane później).

time.ctime

Możesz również reprezentować bieżący czas w drodze preferowanej przez system operacyjny (co oznacza, że może się zmienić, gdy zmienisz preferencje systemowe, więc nie polegaj na tym, aby być standardowym we wszystkich systemach, jak widziałem, jakich innych oczekiwań) . Jest to typowo przyjazny dla użytkownika, ale nie zazwyczaj powoduje ciągi, które można sortować chronologicznie:

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

Można również uwodnić znaczniki czasu do czytelnej formy z ctime:

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

Ta konwersja nie jest również dobra do przechowywania rekordów (z wyjątkiem tekstu, który będzie analizowany tylko przez ludzi - i dzięki ulepszonej rozpoznawaniu charakteru optycznego i sztucznej inteligencji, myślę, że liczba tych przypadków zmniejszy).

Moduł datetime

Moduł datetime jest również przydatny tutaj:

>>> import datetime

datetime.datetime.now

datetime.now jest metodą klasy, która zwraca bieżący czas. Wykorzystuje time.localtime bez informacji o strefach strefowych (jeśli nie podano, w przeciwnym razie patrz świadomy strefy czasu). Ma reprezentację (co pozwoliło na odtworzenie równoważnego obiektu), eched eched na powłoce, ale po wydrukowaniu (lub zmuszony do {{x2}), jest w formacie czytelnym dla człowieka (i prawie ISO) i leksykograficznym Sortuj jest równoważny sortowaniu chronologicznym:

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

Możesz uzyskać obiekt datetime w czasie UTC, standardowy standard, robiąc to:

>>> 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 czasu, który jest prawie równoważny ze strefy czasowej GMT. (Chociaż GMT i UTC nie zmieniają się na czas letni, ich użytkownicy mogą przełączać się na inne strefy czasowe, takich jak brytyjski lato, latem.)

DateTime streetSone świadomy

Jednak żaden z obiektów datetime, do których do tej pory utworzyliśmy, można łatwo konwertować na różne czasy czasowe. Możemy rozwiązać 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 za pomocą instancji UTC {X1}}, co również sprawia, że obiekt jest świadomy strefy czasowej (ale do konwersji na inny moduł czasowy bez przydatny {X2}} Moduł 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, możemy łatwo konwertować na czasowy 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 wykonać naiwny obiekt datetime'a świadomy za pomocą metody pytz localize lub przez zastąpienie atrybutu TzInfo (z replace, jest to działo naślepek), ale są to bardziej ostatni kurort 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 wykonać nasze datetime obiekty czasowe świadomy i konwertować czasy do setek czasowych czasowych dostępnych w module {x2}}.

Można pozornie serializować ten obiekt na czas i przechowywać , że w bazie danych, ale wymagałoby to znacznie więcej pamięci i być bardziej podatnym na błędzie niż po prostu przechowywanie czasu EPOCH UNIX, który pokazałem pierwszy.

Pozostałe sposoby przeglądania czasów są znacznie bardziej podatnym na błędy, zwłaszcza gdy zajmując się danymi, które mogą pochodzić z różnych stref czasowych. Chcesz, aby nie było zamieszania, na które czas trwania lub serializowany obiekt datetime był przeznaczony.

Jeśli wyświetlasz czas z Python dla użytkownika, {x0}} działa ładnie, nie w stole (zwykle dobrze się dobrze sortuje), ale być może w zegarze. Jednak osobiście polecam, gdy radzę sobie z czasem w Pythonie, albo za pomocą czasu UNIX, albo a świadomy czasowe UTC datetime.

Zrobić

from time import time

t = time()

• t - Numer float, dobry do pomiaru przedziału czasu.

Istnieje 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 wysyła bieżący GMT w określonym formacie. Istnieje również localtime() metoda.

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

Poprzednie odpowiedzi są dobre sugestie, ale uważam za korzystanie z ctime():

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

Daje to ładnie sformatowaną reprezentację ciągu bieżącego czasu lokalnego.

Najszybszym sposobem jest:

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

Jeśli potrzebujesz aktualnego czasu jako obiekt {x0}}:

>>> 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 potężne podobne do odpowiedzi @ray Vega):

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

Dlaczego nie zapytać U.S. Obserwatorium Naval, oficjalny czas treningowy Stanów Zjednoczonych Marynarki Wojennej?

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 D.C. (jak ja) opóźnienie może nie być zbyt złe ...

Korzystanie pandas, aby uzyskać bieżący czas, rodzaj nadmiernego przesłania problemu 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)

Wynik:

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

Zastosowanie stolicy Y daje pełny rok i przy użyciu y dałoby 06/02/15.

Możesz również użyć następującego kodu, aby uzyskać więcej czasu:

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

To właśnie skończyło się z:

>>>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 w formacie, aby uzyskać datę sformatowaną po prostu sposób, w jaki chcesz (z Pythona "DateTime" Dokumentacja Oto).

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

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

Tylko data:

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 lokalnym czasie czasowym. Wartość ta może być niejednoznaczna e.g., podczas przejść DST ("Fait Back"). Aby uniknąć dwuznaczności, że 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 strefowy-świadomy, który ma odpowiednie informacje o towarzystwie czasu (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 zwią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 wyjście w formacie YYYY-MM-DD HH:MM:SS:MS. Użyj poniższego skryptu próbnego, aby uzyskać bieżącą datę i godzinę w skrypcie Python i wydruku na ekranie. Utwórz plik getDateTime1.py z poniższą zawartością.

import datetime

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

Wynik wygląda jak poniżej:

2018-03-01 17:03:46.759624

To pytanie nie wymaga nowej odpowiedzi tylko ze względu na to ... błyszcząca nowa zabawka / moduł / moduł ISH wystarczy jednak uzasadnienie. Że jest to biblioteka wahadła, która wydaje się robić rodzaj rzeczy, które próbowano strzałki, z wyjątkiem bez Nieodłączne wady i błędy, które strzały.

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

Jest wiele standardów, które wymagają adresowania, w tym wielu RFC i ISOS. Kiedykolwiek popełnił je; Nie martw się, przejdź trochę do dir(pendulum.constants) Istnieje jednak trochę więcej niż RFC i ISO.

Kiedy mówimy lokalne, choć co myślimy? Mam na myśli:

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

Prawdopodobnie większość reszty znaczy gdzieś indziej.

I na to idzie. Long Story SHORT: Wahenum próbuje zrobić na datę i godzinę, jakie wnioski zrobiły na HTTP. Warto rozważyć, szczególnie zarówno dla swego łatwości użytkowania, jak i szerokiej dokumentacji.

Aktualny czas strefy strefowej

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

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

import arrow
arrow.now()

Lub wersja UTC:

arrow.utcnow()

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

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

Dla określonego czasu:

arrow.now('US/Pacific')

Godzinę temu:

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

Lub jeśli chcesz dystrybucji.

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

Chcę zdobyć czas z milisekundami. Prosty sposób, aby je zdobyć:

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, aby je zdobyć:

import time

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

Dodaj lub usuń zer 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, aby bieżący znacznik czasu w MS (na przykład, aby zmierzyć czas wykonania), możesz także 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 uzyskać godziny, minuty, sekundy i milisekund, aby połączyć się później, możesz użyć tych funkcji:

godzina:

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

minutę:

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

Po drugie:

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

Millisecond:

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

Ponieważ nikt tego nie wspomniał, a to jest coś, w czym wpadłem w ostatnio ... Metoda FromUTC PytZ Timezone () Metoda w połączeniu z DateTime UtCnow () jest najlepszym sposobem, w jaki uznałem przydatny aktualny czas (i data) w dowolnym czasie czasowym.

from datetime import datetime

import pytz


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


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

Jeśli wszystko, co chcesz, jest czas, możesz uzyskać to z local_time.time().

To pytanie dotyczy Pythona, ale ponieważ Django jest jednym z najczęściej używanych ram dla Pythona, ważne jest, aby pamiętać, że jeśli używasz Django, zawsze możesz używać datetime.datetime.now() zamiast datetime.datetime.now(). Ten pierwszy jest czasowy "świadomy", podczas gdy ten ostatni nie jest.

Zobacz Ta taka odpowiedź i Django Doc do szczegółów i uzasadnienia za timezone.now().

from django.utils import timezone

now = timezone.now()