නූල් දිවා කාලයට පරිවර්තනය කිරීම

මට මේ වගේ දින වකවානු වල විශාල ලැයිස්තුවක් තිබේ.

Jun 1 2005  1:33PM
Aug 28 1999 12:00AM

මම මේවා නැවත දත්ත ගබඩාවක නිසි දිවා කාලයේ ක්ෂේත්‍ර වෙත ගෙන යන්නෙමි, එබැවින් ඒවා සැබෑ දිවා කාල වස්තු බවට මැජික් කිරීමට මට අවශ්‍යය.

මෙය ජැන්ගෝගේ ORM හරහා ගමන් කරයි, එබැවින් ඇතුළු කිරීමේ පරිවර්තනය කිරීමට මට SQL භාවිතා කළ නොහැක.

datetime.strptimeයනු දින වකවානු වලට නූල් විග්‍රහ කිරීමේ ප්‍රධාන පුරුද්දයි. එයට සියලු ආකාරයේ ආකෘතීන් හැසිරවිය හැකි අතර, ඔබ එය ලබා දෙන ආකෘතියක් මගින් තීරණය කරනු ලැබේ:

from datetime import datetime

datetime_object = datetime.strptime('Jun 1 2005  1:33PM', '%b %d %Y %I:%M%p')

එහි datetimeප්‍රති ing ලයක් ලෙස කාල කලාපය බොළඳ ය.

සබැඳි:

• සඳහා පයිතන් ප්‍රලේඛනය strptime: පයිතන් 2 , පයිතන් 3

• strptime/ strftimeආකෘති නූල් සඳහා පයිතන් ප්‍රලේඛනය : පයිතන් 2 , පයිතන් 3

• strftime.org යනු strftime සඳහා ඉතා හොඳ යොමු කිරීමකි

සටහන්:

• strptime = "නූල් විග්‍රහ කිරීමේ කාලය"
• strftime = "නූල් හැඩතල කාලය"
• අද එය ශබ්ද නඟා උච්චාරණය කරන්න, ඔබට මාස 6 කින් නැවත එය සෙවීමට අවශ්‍ය නොවේ.

තෙවන පාර්ශවීය දින පුස්තකාලය භාවිතා කරන්න :

from dateutil import parser
parser.parse("Aug 28 1999 12:00AM")  # datetime.datetime(1999, 8, 28, 0, 0)

ඔබට විග්‍රහ කිරීමට අවශ්‍ය ආකෘතිය ඇතුළුව බොහෝ දින ආකෘති එයට හැසිරවිය හැක. strptimeබොහෝ විට නිවැරදි ආකෘතිය අනුමාන කළ හැකි ප්‍රමාණයට වඩා එය පහසු ය .

පරීක්ෂණ ලිවීම සඳහා එය ඉතා ප්‍රයෝජනවත් වේ, එහිදී කාර්ය සාධනයට වඩා කියවීමේ හැකියාව වැදගත් වේ.

ඔබට මෙය ස්ථාපනය කළ හැකිය:

pip install python-dateutil

Strtime බලන්න තුළ කාලය මොඩියුලය. එය strftime හි ප්‍රතිලෝම වේ .

$ python
>>> import time
>>> my_time = time.strptime('Jun 1 2005  1:33PM', '%b %d %Y %I:%M%p')
time.struct_time(tm_year=2005, tm_mon=6, tm_mday=1,
                 tm_hour=13, tm_min=33, tm_sec=0,
                 tm_wday=2, tm_yday=152, tm_isdst=-1)

timestamp = time.mktime(my_time)
# convert time object to datetime
from datetime import datetime
my_datetime = datetime.fromtimestamp(timestamp)
# convert time object to date
from datetime import date
my_date = date.fromtimestamp(timestamp)

සමහර පිළිවෙලට ප්‍රකාශන පරිවර්තනය කළ හැකි ව්‍යාපෘතියක් මම එකට තබා ඇත්තෙමි. කාලරාමුව පරීක්ෂා කරන්න .

මෙන්න පහත උදාහරණ කිහිපයක්:

>>> import timestring
>>> timestring.Date('monday, aug 15th 2015 at 8:40 pm')
<timestring.Date 2015-08-15 20:40:00 4491909392>
>>> timestring.Date('monday, aug 15th 2015 at 8:40 pm').date
datetime.datetime(2015, 8, 15, 20, 40)
>>> timestring.Range('next week')
<timestring.Range From 03/10/14 00:00:00 to 03/03/14 00:00:00 4496004880>
>>> (timestring.Range('next week').start.date, timestring.Range('next week').end.date)
(datetime.datetime(2014, 3, 10, 0, 0), datetime.datetime(2014, 3, 14, 0, 0))

මෙය මතක තබා ගන්න, ඔබ නැවත දිවා කාලයේ පරිවර්තනය කිරීමේදී ව්‍යාකූල වීමට අවශ්‍ය නොවීය.

දිවා කාල වස්තුවට නූල් = strptime

දිවා කාල වස්තුව වෙනත් ආකෘති වලට = strftime

Jun 1 2005 1:33PM

ට සමාන වේ

%b %d %Y %I:%M%p

% b මාසය ප්‍රදේශයේ කෙටි නම ලෙස (ජුනි)

% d ශුන්‍ය පෑඩ් දශම සංඛ්‍යාවක් ලෙස මාසයේ දිනය (1)

ශතවර්ෂය දශම සංඛ්‍යාවක් ලෙස% Y වර්ෂය (2015)

% I පැය (පැය 12 ඔරලෝසුව) ශුන්‍ය පෑඩ් දශම සංඛ්‍යාවක් ලෙස (01)

% M මිනිත්තුව ශුන්‍ය පෑඩ් දශම සංඛ්‍යාවක් ලෙස (33)

% p පෙදෙසි AM හෝ PM (PM) ට සමාන වේ

එබැවින් ඔබට strptime එනම් පරිවර්තනය කිරීම stringඅවශ්‍ය වේ

>>> dates = []
>>> dates.append('Jun 1 2005  1:33PM')
>>> dates.append('Aug 28 1999 12:00AM')
>>> from datetime import datetime
>>> for d in dates:
...     date = datetime.strptime(d, '%b %d %Y %I:%M%p')
...     print type(date)
...     print date
... 

ප්‍රතිදානය

<type 'datetime.datetime'>
2005-06-01 13:33:00
<type 'datetime.datetime'>
1999-08-28 00:00:00

ඔබට විවිධ දින වකවානු තිබේ නම් ඔබට පැන්ඩා හෝ dateutil.parse භාවිතා කළ හැකිය

>>> import dateutil
>>> dates = []
>>> dates.append('12 1 2017')
>>> dates.append('1 1 2017')
>>> dates.append('1 12 2017')
>>> dates.append('June 1 2017 1:30:00AM')
>>> [parser.parse(x) for x in dates]

OutPut

[datetime.datetime(2017, 12, 1, 0, 0), datetime.datetime(2017, 1, 1, 0, 0), datetime.datetime(2017, 1, 12, 0, 0), datetime.datetime(2017, 6, 1, 1, 30)]

පයිතන්> = 3.7.0,

බවට පරිවර්තනය කිරීමට දිනයවේලාව වස්තුවකට දැ ෙ-MM-DD string , datetime.fromisoformatභාවිතා කළ හැකි විය.

>>> from datetime import datetime

>>> date_string = "2012-12-12 10:10:10"
>>> print (datetime.fromisoformat(date_string))
>>> 2012-12-12 10:10:10

බොහෝ කාලරාමු වල ව්‍යංග කාල කලාපයක් ඇත. ඔබේ කේතය සෑම කාල කලාපයකම ක්‍රියාත්මක වන බව සහතික කිරීම සඳහා, ඔබ යූටීසී අභ්‍යන්තරව භාවිතා කළ යුතු අතර විදේශීය වස්තුවක් පද්ධතියට ඇතුළු වන සෑම අවස්ථාවකම කාල කලාපයක් අමුණන්න.

පයිතන් 3.2+:

>>> datetime.datetime.strptime(
...     "March 5, 2014, 20:13:50", "%B %d, %Y, %H:%M:%S"
... ).replace(tzinfo=datetime.timezone(datetime.timedelta(hours=-3)))

දිනයන් නූල් ලෙස හැඩගස්වා ඇති දින වකවානු බවට පත් කිරීම සඳහා පැන්ඩාස් භාවිතා කරන විසඳුම් දෙකක් මෙන්න.

import pandas as pd

dates = ['2015-12-25', '2015-12-26']

# 1) Use a list comprehension.
>>> [d.date() for d in pd.to_datetime(dates)]
[datetime.date(2015, 12, 25), datetime.date(2015, 12, 26)]

# 2) Convert the dates to a DatetimeIndex and extract the python dates.
>>> pd.DatetimeIndex(dates).date.tolist()
[datetime.date(2015, 12, 25), datetime.date(2015, 12, 26)]

වේලාව

dates = pd.DatetimeIndex(start='2000-1-1', end='2010-1-1', freq='d').date.tolist()

>>> %timeit [d.date() for d in pd.to_datetime(dates)]
# 100 loops, best of 3: 3.11 ms per loop

>>> %timeit pd.DatetimeIndex(dates).date.tolist()
# 100 loops, best of 3: 6.85 ms per loop

OP හි මුල් දින-කාලීන උදාහරණ පරිවර්තනය කරන්නේ කෙසේද යන්න මෙන්න:

datetimes = ['Jun 1 2005  1:33PM', 'Aug 28 1999 12:00AM']

>>> pd.to_datetime(datetimes).to_pydatetime().tolist()
[datetime.datetime(2005, 6, 1, 13, 33), 
 datetime.datetime(1999, 8, 28, 0, 0)]

නූල් සිට පැන්ඩාස් ටයිම්ස්ටැම්ප් භාවිතා කිරීම සඳහා බොහෝ විකල්ප ඇත to_datetime, එබැවින් ඔබට විශේෂ යමක් අවශ්‍ය නම් ලියකියවිලි පරීක්ෂා කරන්න .

ඒ හා සමානව, ටයිම්ස්ටැම්ප් වලට අමතරව ප්‍රවේශ විය හැකි බොහෝ ගුණාංග සහ ක්‍රම තිබේ.date

parserමොඩියුලය භාවිතා කරන විසඳුමට මම පෞද්ගලිකව කැමතියි , එය මෙම ප්‍රශ්නයට දෙවන පිළිතුර වන අතර එය ලස්සනයි, මන්ද එය ක්‍රියාත්මක කිරීම සඳහා ඔබට කිසිදු වචනාර්ථයක් සෑදිය යුතු නැත. එහෙත් , එක් අවාසියක් නම් එය පිළිගත් පිළිතුරට වඩා 90% මන්දගාමීstrptime වීමයි.

from dateutil import parser
from datetime import datetime
import timeit

def dt():
    dt = parser.parse("Jun 1 2005  1:33PM")
def strptime():
    datetime_object = datetime.strptime('Jun 1 2005  1:33PM', '%b %d %Y %I:%M%p')

print(timeit.timeit(stmt=dt, number=10**5))
print(timeit.timeit(stmt=strptime, number=10**5))
>10.70296801342902
>1.3627995655316933

ඔබ මෙය නැවත නැවතත් මිලියනයක වාරයක් නොකරන තාක් කල් , මම තවමත් සිතන්නේ මෙම parserක්‍රමය වඩාත් පහසු වන අතර බොහෝ කාල ආකෘති ස්වයංක්‍රීයව හසුරුවනු ඇත.

මෙහි සඳහන් නොවන හා ප්‍රයෝජනවත් දෙයක්: දවසට උපසර්ගයක් එක් කිරීම. මම උපසර්ගය තර්කනය විසන්ධි කළෙමි, එවිට ඔබට එය දින වකවානු නොව ඔබ කැමති ඕනෑම අංකයකට භාවිතා කළ හැකිය.

import time

def num_suffix(n):
    '''
    Returns the suffix for any given int
    '''
    suf = ('th','st', 'nd', 'rd')
    n = abs(n) # wise guy
    tens = int(str(n)[-2:])
    units = n % 10
    if tens > 10 and tens < 20:
        return suf[0] # teens with 'th'
    elif units <= 3:
        return suf[units]
    else:
        return suf[0] # 'th'

def day_suffix(t):
    '''
    Returns the suffix of the given struct_time day
    '''
    return num_suffix(t.tm_mday)

# Examples
print num_suffix(123)
print num_suffix(3431)
print num_suffix(1234)
print ''
print day_suffix(time.strptime("1 Dec 00", "%d %b %y"))
print day_suffix(time.strptime("2 Nov 01", "%d %b %y"))
print day_suffix(time.strptime("3 Oct 02", "%d %b %y"))
print day_suffix(time.strptime("4 Sep 03", "%d %b %y"))
print day_suffix(time.strptime("13 Nov 90", "%d %b %y"))
print day_suffix(time.strptime("14 Oct 10", "%d %b %y"))​​​​​​​

In [34]: import datetime

In [35]: _now = datetime.datetime.now()

In [36]: _now
Out[36]: datetime.datetime(2016, 1, 19, 9, 47, 0, 432000)

In [37]: print _now
2016-01-19 09:47:00.432000

In [38]: _parsed = datetime.datetime.strptime(str(_now),"%Y-%m-%d %H:%M:%S.%f")

In [39]: _parsed
Out[39]: datetime.datetime(2016, 1, 19, 9, 47, 0, 432000)

In [40]: assert _now == _parsed

ජැන්ගෝ ටයිම්සෝන් දැනගත් දිවා කාල වස්තු උදාහරණය.

import datetime
from django.utils.timezone import get_current_timezone
tz = get_current_timezone()

format = '%b %d %Y %I:%M%p'
date_object = datetime.datetime.strptime('Jun 1 2005  1:33PM', format)
date_obj = tz.localize(date_object)

ඔබට ඇති විට ජැන්ගෝ සහ පයිතන් සඳහා මෙම පරිවර්තනය ඉතා වැදගත් වේ USE_TZ = True:

RuntimeWarning: DateTimeField MyModel.created received a naive datetime (2016-03-04 00:00:00) while time zone support is active.

කුඩා උපයෝගීතා ශ්‍රිතයක් සාදන්න:

def date(datestr="", format="%Y-%m-%d"):
    from datetime import datetime
    if not datestr:
        return datetime.today().date()
    return datetime.strptime(datestr, format).date()

මෙය බහුකාර්ය වේ:

• ඔබ කිසිදු තර්කයක් ඉදිරිපත් නොකළහොත් එය අද දිනය නැවත පැමිණේ.
• පෙරනිමියෙන් දින ආකෘතියක් ඔබට අභිබවා යා හැකිය.
• දිවා කාලය නැවත ලබා දීම සඳහා ඔබට එය පහසුවෙන් වෙනස් කළ හැකිය.

එය නූල් දිවා කාලයට පරිවර්තනය කිරීමට සහ කාල කලාපය සමඟ උපකාරී වේ

def convert_string_to_time(date_string, timezone):
    from datetime import datetime
    import pytz
    date_time_obj = datetime.strptime(date_string[:26], '%Y-%m-%d %H:%M:%S.%f')
    date_time_obj_timezone = pytz.timezone(timezone).localize(date_time_obj)

    return date_time_obj_timezone

date = '2018-08-14 13:09:24.543953+00:00'
TIME_ZONE = 'UTC'
date_time_obj_timezone = convert_string_to_time(date, TIME_ZONE)

ඊතලය දිනයන් සහ වේලාවන් සඳහා බොහෝ ප්‍රයෝජනවත් කාර්යයන් ඉදිරිපත් කරයි. මෙම බිට් කේතය ප්‍රශ්නයට පිළිතුරක් සපයන අතර ඊතල පහසුවෙන් දින හැඩතල ගැන්වීමට සහ වෙනත් ස්ථාන සඳහා තොරතුරු ප්‍රදර්ශනය කිරීමට හැකියාව ඇති බව පෙන්වයි.

>>> import arrow
>>> dateStrings = [ 'Jun 1  2005 1:33PM', 'Aug 28 1999 12:00AM' ]
>>> for dateString in dateStrings:
...     dateString
...     arrow.get(dateString.replace('  ',' '), 'MMM D YYYY H:mmA').datetime
...     arrow.get(dateString.replace('  ',' '), 'MMM D YYYY H:mmA').format('ddd, Do MMM YYYY HH:mm')
...     arrow.get(dateString.replace('  ',' '), 'MMM D YYYY H:mmA').humanize(locale='de')
...
'Jun 1  2005 1:33PM'
datetime.datetime(2005, 6, 1, 13, 33, tzinfo=tzutc())
'Wed, 1st Jun 2005 13:33'
'vor 11 Jahren'
'Aug 28 1999 12:00AM'
datetime.datetime(1999, 8, 28, 0, 0, tzinfo=tzutc())
'Sat, 28th Aug 1999 00:00'
'vor 17 Jahren'

වැඩි විස්තර සඳහා http://arrow.readthedocs.io/en/latest/ බලන්න .

එය පහසු කිරීම සඳහා ඔබට පහසු_ දිනය භාවිතා කළ හැකිය :

import date_converter
converted_date = date_converter.string_to_datetime('Jun 1 2005  1:33PM', '%b %d %Y %I:%M%p')

ඔබට දින ආකෘතියක් පමණක් අවශ්‍ය නම්, ඔබේ තනි ක්ෂේත්‍ර පසු කර එය අතින් පරිවර්තනය කළ හැකිය:

>>> import datetime
>>> date = datetime.date(int('2017'),int('12'),int('21'))
>>> date
datetime.date(2017, 12, 21)
>>> type(date)
<type 'datetime.date'>

ඔබගේ බෙදීම් නූල් අගයන් එය දිනය වර්ගයට පරිවර්තනය කිරීමට ඔබට හැකිය:

selected_month_rec = '2017-09-01'
date_formate = datetime.date(int(selected_month_rec.split('-')[0]),int(selected_month_rec.split('-')[1]),int(selected_month_rec.split('-')[2]))

එහි ප්‍රති value ලයක් ලෙස ලැබෙන අගය දිනය ආකෘතියෙන් ඔබට ලැබෙනු ඇත.

ඔබට ද පරීක්ෂා කළ හැකිය dateparser

dateparser වෙබ් පිටු වල බහුලව දක්නට ලැබෙන ඕනෑම සංගීත ආකෘතියක දේශීයකරණය කළ දිනයන් පහසුවෙන් විග්‍රහ කිරීමට මොඩියුල සපයයි.

ස්ථාපනය කරන්න:

$ pip install dateparser

මෙය, මම හිතන්නේ, ඔබට දින විග්‍රහ කළ හැකි පහසුම ක්‍රමය මෙයයි.

වඩාත්ම සරල ක්‍රමය නම් dateparser.parseමොඩියුලයේ බොහෝ ක්‍රියාකාරීත්වයන් වටා එතෙන ශ්‍රිතය භාවිතා කිරීමයි .

නියැදි කේතය:

import dateparser

t1 = 'Jun 1 2005  1:33PM'
t2 = 'Aug 28 1999 12:00AM'

dt1 = dateparser.parse(t1)
dt2 = dateparser.parse(t2)

print(dt1)
print(dt2)

ප්‍රතිදානය:

2005-06-01 13:33:00
1999-08-28 00:00:00

මගේ පිළිතුර බලන්න .

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

අප උත්සාහ කළ යුතුයි ... strptime()නොගැලපෙන සියල්ලන්ටම (විශේෂයෙන්) ව්‍යතිරේකයන් (වෙතින් ) fmt1, fmt2, ..., fmtn අල්ලාගෙන ඒවා හසුරුවන්න / හසුරුවන්න. වගන්ති වගන්ති). සිට මගේ විසඳුමක්

def try_strptime(s, fmts=['%d-%b-%y','%m/%d/%Y']):
    for fmt in fmts:
        try:
            return datetime.strptime(s, fmt)
        except:
            continue

    return None # or reraise the ValueError if no format matched, if you prefer

emp = pd.read_csv("C:\\py\\programs\\pandas_2\\pandas\\employees.csv")
emp.info()

එය "ආරම්භක දිනය වේලාව" තීරුව සහ "අවසන් පිවිසුම් වේලාව" යන දෙකම දත්ත රාමුවේ "වස්තු = නූල්" වේ

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000 entries, 0 to 999
Data columns (total 8 columns):
First Name           933 non-null object
Gender               855 non-null object

Start Date           1000 non-null object

Last Login Time      1000 non-null object

Salary               1000 non-null int64
Bonus %              1000 non-null float64
Senior Management    933 non-null object
Team                 957 non-null object
dtypes: float64(1), int64(1), object(6)
memory usage: 62.6+ KB

සඳහන් කර ඇති parse_datesවිකල්පය භාවිතා කිරීමෙන් read_csvඔබට ඔබේ නූල් දිවා කාලය පැන්ඩා දිවා කාල ආකෘතිය බවට පරිවර්තනය කළ හැකිය.

emp = pd.read_csv("C:\\py\\programs\\pandas_2\\pandas\\employees.csv", parse_dates=["Start Date", "Last Login Time"])
emp.info()


<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000 entries, 0 to 999
Data columns (total 8 columns):
First Name           933 non-null object
Gender               855 non-null object

Start Date           1000 non-null datetime64[ns]
Last Login Time      1000 non-null datetime64[ns]

Salary               1000 non-null int64
Bonus %              1000 non-null float64
Senior Management    933 non-null object
Team                 957 non-null object
dtypes: datetime64[ns](2), float64(1), int64(1), object(4)
memory usage: 62.6+ KB