වත්මන් කාලය ලබා ගැනීම සඳහා භාවිතා කරන මොඩියුලය / ක්‍රමය කුමක්ද?

භාවිත:

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

කාලය:

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

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

ප්‍රලේඛනය බලන්න .

ටයිප් කිරීම සුරැකීමට, ඔබට මොඩියුලයෙන් datetimeවස්තුව ආයාත කළ හැකිය datetime:

>>> from datetime import datetime

ඉන්පසු datetime.ඉහත සියල්ලෙන් ඊයම් ඉවත් කරන්න .

ඔබට භාවිතා කළ හැකිය 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')

මෙම උදාහරණය සඳහා, ප්‍රතිදානය මේ ආකාරයෙන් වනු ඇත: '2013-09-18 11:16:32'

මෙන්න strftimeනියෝග ලැයිස්තුව .

හාර්ලිගේ පිළිතුරට සමානය , නමුත් str()ශ්‍රිතය ඉක්මන්-අපිරිසිදු, තරමක් වැඩි මිනිස් කියවිය හැකි ආකෘතියක් සඳහා භාවිතා කරන්න:

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

පයිතන් හි වත්මන් කාලය ලබා ගන්නේ කෙසේද?

එම time මොඩියුලය

මෙම timeමොඩියුලය අපට "ධනපතියන්ගේ යුගයක් සිට තත්පර" තුළ ඇති කාලය මෙන්ම අනෙකුත් උපයෝගිතා කියනවා කාර්ය සපයනු ලැබේ.

import time

යුනික්ස් යුගය කාලය

දත්ත සමුදායන් සුරැකීම සඳහා ඔබ කාලරාමු ලබා ගත යුතු ආකෘතිය මෙයයි. එය පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කළ හැකි සරල පාවෙන ලක්ෂ්‍ය අංකයකි. එය තත්පර කිහිපයකින් අංක ගණිතයටද හොඳය, එය 1970 ජනවාරි 1 සිට 00:00:00 දක්වා තත්පර ගණන නිරූපණය කරන අතර, එය ඊළඟට අපි බලා සිටින කාලයෙහි අනෙක් නිරූපණයන්ට සාපේක්ෂව මතක ආලෝකය වේ:

>>> time.time()
1424233311.771502

මෙම කාලරාමුව පිම්ම තත්පරයට ගණන් නොගනී, එබැවින් එය රේඛීය නොවේ - පිම්ම තත්පර නොසලකා හරිනු ලැබේ. එබැවින් එය අන්තර්ජාතික යූටීසී ප්‍රමිතියට සමාන නොවන අතර, එය සමීප වන අතර එබැවින් වාර්තා තබා ගැනීමේ බොහෝ අවස්ථාවන් සඳහා එය ඉතා හොඳය.

කෙසේ වෙතත් මෙය මානව උපලේඛනගත කිරීම සඳහා වඩාත් සුදුසු නොවේ. ඔබට යම් නිශ්චිත වේලාවක සිදුවීමට අවශ්‍ය අනාගත සිදුවීමක් තිබේ නම්, ඔබට එම කාලය දිවා කාල වස්තුවකට හෝ අනුක්‍රමික දිවා කාල වස්තුවකට විග්‍රහ කළ හැකි නූලක් සමඟ ගබඩා කිරීමට අවශ්‍ය වනු ඇත (මේවා පසුව විස්තර කෙරේ).

time.ctime

ඔබේ මෙහෙයුම් පද්ධතිය විසින් කැමති ආකාරයට වර්තමාන වේලාවද ඔබට නිරූපණය කළ හැකිය (එයින් අදහස් වන්නේ ඔබ ඔබේ පද්ධති මනාපයන් වෙනස් කරන විට එය වෙනස් විය හැකි බවයි, එබැවින් අනෙක් අය අපේක්ෂා කරන පරිදි මෙය සියලු පද්ධති හරහා ප්‍රමිතිගත වීමට රඳා නොසිටින්න) . මෙය සාමාන්‍යයෙන් පරිශීලක හිතකාමී වන නමුත් සාමාන්‍යයෙන් කෙනෙකුට කාලානුක්‍රමිකව වර්ග කළ හැකි නූල් ඇති නොවේ:

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

ඔබට කාලරාමුව මිනිස් කියවිය හැකි ආකාරයෙන් හයිඩ්‍රේට් කළ හැකිය ctime:

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

මෙම පරිවර්තනය වාර්තා තබා ගැනීම සඳහා ද හොඳ නැත (මිනිසුන් විසින් පමණක් විග්‍රහ කරනු ලබන පෙළ හැර - සහ වැඩි දියුණු කරන ලද දෘෂ්‍ය අක්ෂර හඳුනාගැනීම සහ කෘතිම බුද්ධිය සමඟ, මෙම අවස්ථා ගණන අඩු වනු ඇතැයි මම සිතමි).

datetime මොඩියුලය

මෙම datetimeමොඩියුලය මෙතන බෙහෙවින් ප්රයෝජනවත් වේ:

>>> import datetime

datetime.datetime.now

මෙම datetime.nowවර්තමාන කාලය නැවත බව පන්ති ක්රමය වේ. එය time.localtimeකාල කලාප තොරතුරු රහිතව භාවිතා කරයි (ලබා දී නොමැති නම්, පහත දැක්වෙන කාල කලාපය බලන්න). එය නිරූපණයක් ඇත (එමඟින් ඔබට සමාන වස්තුවක් ප්‍රතිනිර්මාණය කිරීමට ඉඩ සලසයි) කවචයේ දෝංකාර දෙයි, නමුත් මුද්‍රණය කරන විට (හෝ අ str) වෙත බල කරන විට එය මිනිස් කියවිය හැකි (සහ ආසන්න වශයෙන් අයිඑස්ඕ) ආකෘතියෙන් වන අතර ශබ්දකෝෂ වර්ගීකරණය සමාන වේ කාලානුක්‍රමික වර්ග කිරීම:

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

දිවා කාලයේ utcnow

මෙය කිරීමෙන් ඔබට ගෝලීය ප්‍රමිතියක් වන යූටීසී වේලාවෙන් දිවා කාල වස්තුවක් ලබා ගත හැකිය:

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

UTC යනු GMT කාල කලාපයට ආසන්න වශයෙන් සමාන වන කාල ප්‍රමිතියකි. (දිවා ආලෝකය ඉතිරි කිරීමේ වේලාව සඳහා GMT සහ UTC වෙනස් නොවන අතර, ඔවුන්ගේ පරිශීලකයින්ට ගිම්හාන කාලය තුළ බ්‍රිතාන්‍ය ගිම්හාන කාලය වැනි වෙනත් කාල කලාප වෙත මාරු විය හැකිය.)

දිවා කාල කාල කලාපය දැනුවත්

කෙසේ වෙතත්, අප මෙතෙක් නිර්මාණය කර ඇති දිවා කාල වස්තු කිසිවක් විවිධ කාල කලාපවලට පහසුවෙන් පරිවර්තනය කළ නොහැක. pytzමොඩියුලය සමඟ අපට එම ගැටළුව විසඳා ගත හැකිය :

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

ඒ හා සමානව, පයිතන් 3 හි අප සතුව timezoneපංතියක් ඇත. timezoneඑය වස්තු කාල කලාපය ද දැනුවත් කරයි (නමුත් පහසු pytzමොඩියුලයක් නොමැතිව වෙනත් කාල කලාපයක් බවට පරිවර්තනය කිරීම පා er කයාට අභ්‍යාසයක් ලෙස ඉතිරි වේ):

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

මුල් 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

ඔබට pytzකාල localizeකලාප ක්‍රමය සමඟ බොළඳ දිවා කාල වස්තුවක් දැනුවත් කළ හැකිය , නැතහොත් ටින්ෆෝ ගුණාංගය ප්‍රතිස්ථාපනය කිරීමෙන් ( replaceමෙය අන්ධ ලෙස සිදු කරනු ලැබේ), නමුත් මේවා හොඳම භාවිතයන්ට වඩා අවසාන නිකේතන වේ:

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

මෙම pytzමොඩියුලය, අපේ කිරීමට ඉඩ datetimeවස්තූන් දැනුවත් වේලා කලාපය හා ලබා ගත හැකි වේලාකලාප සිය ගණනක් සඳහා වරක් පරිවර්තනය pytzමොඩියුලය.

යමෙකුට මෙම වස්තුව යූටීසී වේලාවට පෙනෙන පරිදි අනුක්‍රමික කර දත්ත ගබඩාවක ගබඩා කළ හැකිය, නමුත් එයට මා විසින් මුලින්ම නිරූපණය කළ යුනික්ස් යුගය කාලය ගබඩා කරනවාට වඩා වැඩි මතකයක් අවශ්‍ය වන අතර දෝෂ වලට ගොදුරු විය හැකිය.

නැරඹීමේ වේලාවන්හි අනෙක් ක්‍රම වඩාත් දෝෂ සහිත වේ, විශේෂයෙන් විවිධ කාල කලාපවලින් පැමිණිය හැකි දත්ත සමඟ කටයුතු කිරීමේදී. නූලක් හෝ අනුක්‍රමික දිවා කාල වස්තුවක් කුමන කාල කලාපයක් සඳහා අදහස් කර ඇත්ද යන්න පිළිබඳව ව්‍යාකූලත්වයක් ඇති නොවීමට ඔබට අවශ්‍යය.

ඔබ පරිශීලකයා සඳහා පයිතන් සමඟ කාලය ප්‍රදර්ශනය කරන්නේ නම් ctime, මේසයක් තුළ නොව (එය සාමාන්‍යයෙන් හොඳින් වර්ග නොකෙරේ), නමුත් සමහර විට ඔරලෝසුවක හොඳින් ක්‍රියා කරයි. කෙසේ වෙතත්, මම පෞද්ගලිකව නිර්දේශ කරන්නේ, පයිතන් හි කාලය සමඟ ගනුදෙනු කිරීමේදී, යුනික්ස් වේලාව භාවිතා කිරීම හෝ කාල කලාපයක් දන්නා UTC datetimeවස්තුවක් භාවිතා කිරීම ය.

කරන්න

from time import time

t = time()

• t - පාවෙන අංකය, කාල පරතරය මැනීමට හොඳයි.

යුනික්ස් සහ වින්ඩෝස් වේදිකා සඳහා යම් වෙනසක් තිබේ.

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

එය වත්මන් GMT නිශ්චිත ආකෘතියෙන් ප්‍රතිදානය කරයි. localtime()ක්‍රමයක් ද තිබේ .

මෙම පිටුවේ වැඩි විස්තර ඇත.

පෙර පිළිතුරු සියල්ලම හොඳ යෝජනා, නමුත් එය භාවිතා කිරීම පහසු බව මට පෙනේ ctime():

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

මෙය වර්තමාන දේශීය වේලාව මනාව හැඩගස්වා ඇති නූල් නිරූපණයක් ලබා දෙයි.

ඉක්මන්ම ක්‍රමය නම්:

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

timeවස්තුවක් ලෙස ඔබට වත්මන් කාලය අවශ්‍ය නම් :

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

.isoformat() ප්‍රලේඛනයෙහි ඇත, නමුත් තවමත් මෙහි නොමැත (මෙය ay රේ වේගාගේ පිළිතුරට සමාන ය):

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

එක්සත් ජනපද නාවික හමුදාවේ නිල කාල පාලකයා වන එක්සත් ජනපද නාවික නිරීක්ෂණාගාරයෙන් විමසන්නේ නැත්තේ ඇයි ?

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

ඔබ ජීවත් වන්නේ ඩීසී ප්‍රදේශයේ නම් (මා වැනි) ප්‍රමාදය එතරම් නරක නොවනු ඇත ...

වර්තමාන වේලාව ලබා ගැනීම සඳහා පැන්ඩා භාවිතා කිරීම, ගැටලුව අත ළඟ තබා ගැනීම:

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)

ප්‍රතිදානය:

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

මෙය මා සමඟ අවසන් වූයේ:

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

එසේම, මෙම වගුව ඔබට අවශ්‍ය ආකාරයට ආකෘතිකරණය කර ගැනීම සඳහා සුදුසු ආකෘති කේත තෝරා ගැනීම සඳහා අත්‍යවශ්‍ය යොමු කිරීමකි ( මෙහි පයිතන් "දිවා කාලයේ" ප්‍රලේඛනයෙන් ).

ඔබ දැනටමත් අංක භාවිතා කරන්නේ නම් කෙලින්ම ඔබට numpy.datetime64 () ශ්‍රිතය භාවිතා කළ හැකිය.

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

එකම දිනය සඳහා:

str(np.datetime64('today'))

හෝ, ඔබ දැනටමත් පැන්ඩා භාවිතා කරන්නේ නම් ඔබට pandas.to_datetime () ශ්‍රිතය භාවිතා කළ හැකිය

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

හෝ,

str(pd.to_datetime('today'))

ඔබට timeමොඩියුලය භාවිතා කළ හැකිය :

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

>>> 06/02/2015

ප්රාග්ධනය භාවිතා කිරීම Y සම්පූර්ණ වසර ලබා දෙයි, සහ භාවිතා yකිරීම ලබා දෙනු 06/02/15ඇත.

වඩාත් දීර් time කාලයක් ලබා දීම සඳහා ඔබට පහත කේතය භාවිතා කළ හැකිය:

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

datetime.now()වර්තමාන වේලාව දේශීය කාල කලාපයේ කාලය නිරූපණය කරන බොළඳ දිවා කාල වස්තුවක් ලෙස ලබා දෙයි. එම අගය අපැහැදිලි විය හැකිය. අපැහැදිලි භාවය වළක්වා ගැනීම සඳහා යූටීසී කාල කලාපය භාවිතා කළ යුතුය:

from datetime import datetime

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

හෝ අනුරූප කාල කලාප තොරතුරු අමුණා ඇති කාල කලාප-දැනුවත් වස්තුවක් (පයිතන් 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

කරන්න dir(date)හෝ පැකේජය ඇතුළු ඕනෑම විචල්‍යයක්. විචල්යයට සම්බන්ධ සියලු ගුණාංග සහ ක්රම ඔබට ලබා ගත හැකිය.

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

පෙරනිමියෙන්, now()ශ්‍රිතය YYYY-MM-DD HH:MM:SS:MSආකෘතියෙන් ප්‍රතිදානය ලබා දෙයි . පයිතන් පිටපතක වත්මන් දිනය හා වේලාව ලබා ගැනීමට පහත නියැදි පිටපත භාවිතා කර ප්‍රති results ල තිරය මත මුද්‍රණය කරන්න. getDateTime1.pyපහත අන්තර්ගතය සමඟ ගොනුවක් සාදන්න .

import datetime

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

ප්‍රතිදානය පහත පරිදි වේ:

2018-03-01 17:03:46.759624

මෙම ප්‍රශ්නයට නව පිළිතුරක් අවශ්‍ය නොවේ ... දිලිසෙන නව-සෙල්ලම් බඩු / මොඩියුලයක්, කෙසේ වෙතත්, ප්‍රමාණවත් තරම් සාධාරණීකරණය කිරීම. එය පෙන්ඩුලම් පුස්තකාලයයිඊතලය වටා ඇති ආවේනික අඩුපාඩු හා දෝෂ නොමැතිව හැර, ඊතලය උත්සාහ කළ ආකාරයේ දේවල් කරන බව පෙනෙන .

උදාහරණයක් ලෙස, මුල් ප්‍රශ්නයට පිළිතුර:

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

කනස්සල්ලට පත්වීම සඳහා බහු RFC සහ ISO ඇතුළුව ආමන්ත්‍රණය කළ යුතු ප්‍රමිතීන් රාශියක් ඇත. කවදා හෝ ඒවා මිශ්ර කරන්න; කණගාටු නොවන්න, මඳක් සොයා බලන්න dir(pendulum.constants)RFC සහ ISO ආකෘති වලට වඩා ටිකක් වැඩි ය.

අපි දේශීය යැයි පැවසූ විට, අප අදහස් කරන්නේ කුමක්ද? හොඳයි මම අදහස් කළේ:

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

අනුමාන වශයෙන් ඔබ අනෙක් බොහෝ දෙනා අදහස් කරන්නේ වෙනත් තැනක ය.

එය ඉදිරියට යයි. දිගු කථා කෙටිකතාව: පෙන්ඩුලම් HTTP සඳහා ඉල්ලීම් කළ දිනය හා වේලාව සඳහා උත්සාහ කරයි. විශේෂයෙන් එහි භාවිතයේ පහසුව සහ පුළුල් ලියකියවිලි යන දෙකම සලකා බැලීම වටී.

කාල කලාපයක වත්මන් කාලය

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

ඊතල මොඩියුලය http://crsmithdev.com/arrow/ වෙතින් උත්සාහ කරන්න :

import arrow
arrow.now()

හෝ UTC අනුවාදය:

arrow.utcnow()

එහි ප්‍රතිදානය වෙනස් කිරීමට .format () එක් කරන්න:

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

නිශ්චිත කාල කලාපයක් සඳහා:

arrow.now('US/Pacific')

පැයකට කලින්:

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

නැතහොත් ඔබට සාරාංශය අවශ්‍ය නම්.

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

මට මිලි තත්පර සමඟ කාලය ලබා ගැනීමට අවශ්‍යයි. ඒවා ලබා ගැනීම සඳහා සරල ක්‍රමයක්:

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

දශම ලක්ෂ්‍ය ගණන වෙනස් කිරීම සඳහා අවසාන ගුණ කිරීමෙන් ශුන්‍ය එකතු කරන්න හෝ ඉවත් කරන්න, හෝ:

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

ඔබට එම්එස් හි වත්මන් කාලරාමුව අවශ්‍ය නම් (නිදසුනක් ලෙස, ක්‍රියාත්මක කිරීමේ කාලය මැනීමට), ඔබට “ටයිමිට්” මොඩියුලය ද භාවිතා කළ හැකිය:

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

කාලය ලබා ගැනීම සඳහා ඔබට මෙම ශ්‍රිතය භාවිතා කළ හැකිය (අවාසනාවකට එය AM හෝ PM නොකියයි):

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

පසුව ඒකාබද්ධ වීමට පැය, මිනිත්තු, තත්පර සහ මිලි තත්පර ලබා ගැනීමට, ඔබට මෙම කාර්යයන් භාවිතා කළ හැකිය:

පැය:

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

මිනිත්තුව:

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

දෙවැනි:

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

මිලි තත්පර:

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

කිසිවෙකු තවම එය සඳහන් කර නැති නිසාත්, මෙය මා මෑතකදී දිව ගිය දෙයක් නිසාත් ... පයිට්ස් කාල කලාපයේ ෆ්‍රොමූට් () ක්‍රමය දිවා කාලයේ උට්කෝනෝ () සමඟ ඒකාබද්ධ වී ප්‍රයෝජනවත් වත්මන් වේලාවක් (සහ දිනය) ලබා ගැනීමට මා සොයාගත් හොඳම ක්‍රමයයි. ඕනෑම කාල කලාපයක.

from datetime import datetime

import pytz


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


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

ඔබට අවශ්‍ය සියල්ල කාලය නම්, ඔබට එය ලබා ගත හැකිය local_time.time().

පහත දැක්වෙන්නේ මම ආකෘතිකරණයකින් තොරව කාලය ලබා ගැනීමට භාවිතා කරන දෙයයි. සමහර අය බෙදීම් ක්‍රමයට කැමති නැත, නමුත් එය මෙහි ප්‍රයෝජනවත් වේ:

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

එය HH: MM: SS ආකෘතියෙන් මුද්‍රණය වේ.

වත්මන් දිනය කාල ලක්ෂණ ලබා ගන්න:

import datetime

currentDT = datetime.datetime.now()

print ("Current Year is: %d" % currentDT.year)
print ("Current Month is: %d" % currentDT.month)
print ("Current Day is: %d" % currentDT.day)
print ("Current Hour is: %d" % currentDT.hour)
print ("Current Minute is: %d" % currentDT.minute)
print ("Current Second is: %d" % currentDT.second)
print ("Current Microsecond is: %d" % currentDT.microsecond)


#!/usr/bin/python
import time;

ticks = time.time()
print "Number of ticks since "12:00am, Jan 1, 1970":", ticks

මෙම ප්‍රශ්නය පයිතන් සඳහා වන නමුත් ජැන්ගෝ යනු පයිතන් සඳහා වැඩිපුරම භාවිතා වන රාමුවක් වන බැවින්, ඔබ ජැන්ගෝ භාවිතා කරන්නේ නම් timezone.now()ඒ වෙනුවට සෑම විටම භාවිතා කළ හැකි බව සැලකිල්ලට ගැනීම වැදගත්ය datetime.datetime.now(). පළමුවැන්න කාල කලාපය 'දැනුවත්' වන අතර දෙවැන්න නොදැනේ.

බලන්න මෙම SO පිළිතුර හා Django ලේඛය විස්තර හා තාර්කිකත්වය පිටුපස සඳහා timezone.now().

from django.utils import timezone

now = timezone.now()