પાયથોન ડેટટાઇમ (strftime, strptime) માં તારીખો અને સમયને સ્ટ્રિંગ્સમાં અને માંથી રૂપાંતરિત કરવું

બિઝનેસ

Python ની પ્રમાણભૂત લાઇબ્રેરી datetime નો ઉપયોગ તારીખો અને સમય (તારીખ, સમય અને સમય) પર પ્રક્રિયા કરવા માટે થઈ શકે છે. પદ્ધતિઓ strftime() અને strptime(), જે તારીખો અને સમયને શબ્દમાળામાં અને માંથી રૂપાંતરિત કરે છે, તેનો ઉપયોગ વિવિધ ફોર્મેટમાં તારીખો અને સમયને ચાલાકી કરવા માટે થઈ શકે છે.

તે બાદબાકી અને સરવાળો જેવી કામગીરી પણ કરી શકે છે. ઉદાહરણ તરીકે, તમે સરળતાથી ગણતરી કરી શકો છો અને 10 દિવસ પહેલાની તારીખ અથવા હવેથી 3 અઠવાડિયા અથવા હવેથી 50 મિનિટનો સમય મેળવી શકો છો.

પ્રથમ, અમે તારીખ સમય મોડ્યુલમાં ઉપલબ્ધ વસ્તુઓના નીચેના વર્ગોનું વર્ણન કરીશું.

  • datetime.datetime:તારીખ અને સમય (તારીખ અને સમય)
  • datetime.date:તારીખ
  • datetime.time:સમય
  • datetime.timedelta:સમયનો તફાવત અને વીતી ગયેલો સમય

પદ્ધતિઓ strftime() અને strptime(), જે તારીખ/સમય અને સ્ટ્રીંગને એકબીજામાં રૂપાંતરિત કરે છે, તે પણ સમજાવવામાં આવે છે.

  • datetimeપદાર્થ
    • datetime.now():આજની તારીખ, વર્તમાન સમય
    • datetimeઑબ્જેક્ટ કન્સ્ટ્રક્ટર
    • તારીખ સમયના ઑબ્જેક્ટને તારીખ ઑબ્જેક્ટમાં રૂપાંતરિત કરવું
  • dateપદાર્થ
    • date.today():આજની તારીખ
    • તારીખ ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર
  • timeપદાર્થ
    • ટાઇમ ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર
  • timedeltaપદાર્થ
    • ટાઇમડેલ્ટા ઑબ્જેક્ટ્સ બનાવવા માટે તારીખ સમય અને તારીખ ઑબ્જેક્ટ્સને બાદ કરો.
    • ટાઇમડેલ્ટા ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર
    • ટાઈમડેલ્ટા ઓબ્જેક્ટનો ઉપયોગ કરીને બાદબાકી અને સરવાળો
  • strftime():તારીખ અને સમય થી સ્ટ્રિંગ માં રૂપાંતર
  • strptime():શબ્દમાળાથી તારીખ અને સમય સુધીનું રૂપાંતરણ

પ્રમાણભૂત લાઇબ્રેરીમાં કૅલેન્ડર મોડ્યુલ પણ શામેલ છે, જે સાદા ટેક્સ્ટ અથવા HTML ફોર્મેટમાં કૅલેન્ડર્સ જનરેટ કરે છે.

તારીખ સમય પદાર્થ

ડેટટાઇમ ઑબ્જેક્ટ એ ઑબ્જેક્ટ છે જેમાં તારીખ (વર્ષ, મહિનો, દિવસ) અને સમય (કલાક, મિનિટ, સેકન્ડ, માઇક્રોસેકન્ડ) બંને માહિતી હોય છે. તમે નીચેની વિશેષતાઓ સાથે તે માહિતીને ઍક્સેસ કરી શકો છો.

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

datetime.now():આજની તારીખ, વર્તમાન સમય

datetime.now() તમને આજની તારીખ (વર્તમાન તારીખ) અને વર્તમાન સમય સાથે તારીખ સમયનો ઑબ્જેક્ટ આપશે.

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

ડેટટાઇમ ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર

મનસ્વી તારીખો અને સમય માટે ડેટટાઇમ ઑબ્જેક્ટ્સ જનરેટ કરવાનું પણ શક્ય છે.

ડેટટાઇમ ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર નીચે મુજબ છે.

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

નીચેના મૂલ્યો જરૂરી છે અને અન્યને અવગણી શકાય છે. જો અવગણવામાં આવે, તો ડિફોલ્ટ મૂલ્ય 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

તારીખ સમયના ઑબ્જેક્ટને તારીખ ઑબ્જેક્ટમાં રૂપાંતરિત કરવું

ડેટટાઇમ ઑબ્જેક્ટને date() પદ્ધતિ દ્વારા તારીખ ઑબ્જેક્ટમાં રૂપાંતરિત કરી શકાય છે, આગળ વર્ણવ્યા પ્રમાણે.

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

તારીખ પદાર્થ

તારીખ ઑબ્જેક્ટ એ ઑબ્જેક્ટ છે જેમાં તારીખ (વર્ષ, મહિનો, દિવસ) વિશેની માહિતી હોય છે. તે લક્ષણો વર્ષ, મહિનો અને દિવસ દ્વારા ઍક્સેસ કરી શકાય છે.

date.today():આજની તારીખ

વર્તમાન તારીખ (આજની તારીખ) ની તારીખ ઑબ્જેક્ટ 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

તારીખ ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર

તારીખ ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર નીચે મુજબ છે

date(year, month, day)

બધા જરૂરી છે અને અવગણી શકાય નહીં.

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

print(d.month)
# 2

સમય પદાર્થ

ટાઇમ ઑબ્જેક્ટ એ એક ઑબ્જેક્ટ છે જેમાં સમય (કલાક, મિનિટ, સેકન્ડ અને માઇક્રોસેકન્ડ) વિશેની માહિતી હોય છે. તે કલાક, મિનિટ, સેકન્ડ અને માઇક્રોસેકન્ડના લક્ષણોનો ઉપયોગ કરીને ઍક્સેસ કરી શકાય છે.

ટાઇમ ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર

ટાઈમ ઓબ્જેક્ટનો કન્સ્ટ્રક્ટર નીચે મુજબ છે.

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

તે બધા વૈકલ્પિક છે, અને જો તે અવગણવામાં આવે છે, તો તે 0 પર સેટ છે.

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

ટાઇમડેલ્ટા ઑબ્જેક્ટ

ટાઇમડેલ્ટા ઑબ્જેક્ટ એ એક ઑબ્જેક્ટ છે જે બે તારીખો અને સમય, અથવા વીતી ગયેલા સમય વચ્ચેના સમયના તફાવતને રજૂ કરે છે. તે દિવસો, સેકન્ડ અને માઇક્રોસેકન્ડમાં માહિતી ધરાવે છે, અને લક્ષણો દિવસો, સેકન્ડ્સ અને માઇક્રોસેકન્ડ્સ દ્વારા ઍક્સેસ કરી શકાય છે. total_seconds() પદ્ધતિનો ઉપયોગ કરીને સેકંડની કુલ સંખ્યા મેળવવી પણ શક્ય છે.

ટાઇમડેલ્ટા ઑબ્જેક્ટ બનાવવા માટે તારીખ સમય અને તારીખ ઑબ્જેક્ટને બાદ કરો.

ડેટટાઇમ ઑબ્જેક્ટ્સને એકબીજામાંથી બાદ કરવાથી ટાઇમડેલ્ટા ઑબ્જેક્ટ મળે છે.

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

એકબીજામાંથી તારીખની વસ્તુઓની બાદબાકી એ જ રીતે ટાઇમડેલ્ટા ઑબ્જેક્ટ આપે છે.

ટાઇમડેલ્ટા ઑબ્જેક્ટ માટે કન્સ્ટ્રક્ટર

ટાઈમડેલ્ટા ઓબ્જેક્ટનો કન્સ્ટ્રક્ટર નીચે મુજબ છે

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

તે બધા વૈકલ્પિક છે, અને જો તે અવગણવામાં આવે છે, તો તે 0 પર સેટ છે.

નોંધ કરો કે ટાઇમડેલ્ટા ઑબ્જેક્ટ ફક્ત નીચેની માહિતી ધરાવે છે.

  • ઘણા દિવસો:days
  • સેકન્ડની સંખ્યા:seconds
  • માઇક્રોસેકન્ડ ગણતરી:microseconds

ઉદાહરણ તરીકે, નીચેના બે સમાન છે

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

print(td_1w.days)
# 7

ટાઈમડેલ્ટા ઓબ્જેક્ટનો ઉપયોગ કરીને બાદબાકી અને સરવાળો

ટાઈમડેલ્ટા ઑબ્જેક્ટનો ઉપયોગ બાદબાકી અને સરવાળો જેવા ઑપરેશન કરવા માટે તારીખ સમય અને તારીખ ઑબ્જેક્ટ સાથે થઈ શકે છે. ઉદાહરણ તરીકે, તમે સરળતાથી ગણતરી કરી શકો છો અને એક અઠવાડિયા પહેલાની તારીખ અથવા હવેથી 10 દિવસ અથવા હવેથી 50 મિનિટનો સમય મેળવી શકો છો.

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

તેનો ઉપયોગ ચોક્કસ તારીખ સુધી દિવસોની સંખ્યાની ગણતરી કરવા માટે પણ થઈ શકે છે.

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

print(td.days)
# 903

strftime():તારીખ અને સમય થી સ્ટ્રિંગ માં રૂપાંતર

તારીખ સમય અને તારીખ ઑબ્જેક્ટ્સની strftime() પદ્ધતિનો ઉપયોગ તારીખ અને સમય (તારીખ અને સમય) માહિતીને કોઈપણ ફોર્મેટ ફોર્મેટમાં સ્ટ્રિંગમાં કન્વર્ટ કરવા માટે થઈ શકે છે.

ફોર્મેટિંગ કોડ

ઉપલબ્ધ ફોર્મેટિંગ કોડ્સ માટે નીચે અધિકૃત દસ્તાવેજીકરણ જુઓ.

મુખ્ય ફોર્મેટિંગ કોડ્સ નીચે સૂચિબદ્ધ છે.

  • %d:શૂન્ય ભરેલ સાથે દશાંશ સંકેતમાં મહિનાનો દિવસ.
  • %m:શૂન્ય ભરેલ સાથે દશાંશ સંકેતમાં મહિનો.
  • %y:શૂન્યથી ભરેલા દશાંશ સંકેતમાં વર્ષના છેલ્લા બે અંકો.
  • %Y:શૂન્ય ભરેલ સાથે દશાંશ સંકેતમાં વર્ષના ચાર અંકો.
  • %H:જ્યારે શૂન્ય ભરેલા દશાંશ સંકેતમાં દર્શાવવામાં આવે છે (24-કલાક સંકેત)
  • %I:જ્યારે શૂન્ય ભરેલા દશાંશ સંકેતમાં દર્શાવવામાં આવે છે (12-કલાક સંકેત)
  • %M:ભરેલ શૂન્ય સાથે દશાંશ સંકેત માટે.
  • %S:શૂન્ય ભરેલ સાથે દશાંશ સંકેતમાં સેકન્ડ.
  • %f:દશાંશ સંકેતમાં માઇક્રોસેકન્ડ્સ (6 અંકો) 0 ભરેલા છે.
  • %A:લોકેલ માટે અઠવાડિયાના દિવસનું નામ
  • %a:લોકેલ માટે દિવસનું નામ (સંક્ષિપ્ત સ્વરૂપ)
  • %B:સ્થાનિક મહિનાનું નામ
  • %b:સ્થાનિક મહિનાનું નામ (સંક્ષિપ્ત સ્વરૂપ)
  • %j:શૂન્ય ભરણ સાથે દશાંશ સંકેતમાં વર્ષનો દિવસ.
  • %U:શૂન્ય ભરણ સાથે દશાંશ સંકેતમાં વર્ષના અઠવાડિયાની સંખ્યા (અઠવાડિયું રવિવારથી શરૂ થાય છે)
  • %W:શૂન્ય ભરણ સાથે દશાંશ સંકેતમાં વર્ષના અઠવાડિયાની સંખ્યા (સપ્તાહ સોમવારથી શરૂ થાય છે)

દિવસ અને મહિનાના નામ માટે નીચેના ફોર્મેટિંગ કોડ લોકેલના આધારે અલગ-અલગ સ્ટ્રીંગમાં મેળવી શકાય છે.

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

ISO 8601 ફોર્મેટ સ્ટ્રીંગ્સ માટે એક સમર્પિત પદ્ધતિ પણ છે.

નમૂના કોડ

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

જો તમે સ્ટ્રિંગને બદલે નંબર મેળવવા માંગતા હો, તો તેને int() સાથે પૂર્ણાંકમાં કન્વર્ટ કરો.

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

ટાઇમડેલ્ટા ઑબ્જેક્ટ સાથે સંયોજનમાં, તે બનાવવું સરળ છે, ઉદાહરણ તરીકે, કોઈપણ ફોર્મેટમાં દ્વિ-સાપ્તાહિક તારીખોની સૂચિ.

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

સૂચિ સમજણ સંકેતનો ઉપયોગ કરવો વધુ સ્માર્ટ છે.

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():શબ્દમાળાથી તારીખ અને સમય સુધીનું રૂપાંતરણ

datetime strptime() નો ઉપયોગ તારીખ અથવા સમય શબ્દમાળામાંથી datetime ઑબ્જેક્ટ બનાવવા માટે થઈ શકે છે. મૂળ સ્ટ્રિંગને અનુરૂપ ફોર્મેટિંગ સ્ટ્રિંગનો ઉલ્લેખ કરવો જરૂરી છે.

ISO 8601 સ્ટ્રીંગ્સ (Python 3.7 અથવા પછીની) માટે એક સમર્પિત પદ્ધતિ પણ છે.

નમૂના કોડ

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

પુનઃપ્રાપ્ત datetime ઑબ્જેક્ટ પર strftime() પદ્ધતિનો ઉપયોગ કરીને, તમે તારીખ અને સમયને મૂળ શબ્દમાળા કરતાં અલગ ફોર્મેટમાં રજૂ કરી શકો છો.

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

જો તમે તેને ડેટટાઇમ ઑબ્જેક્ટમાં કન્વર્ટ કરો છો, તો તમે ટાઇમડેલ્ટા ઑબ્જેક્ટ સાથે ઑપરેશન પણ કરી શકો છો, તેથી ઉદાહરણ તરીકે, તમે સમાન ફોર્મેટમાં 10 દિવસ પહેલાંની તારીખની સ્ટ્રિંગ જનરેટ કરી શકો છો.

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