blocks|key|2552593|text|我不知道有什么方法可以从dateutil+(或我所知道的任何其他python时间戳解析器)返回解析后的格式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2552594|使用datetime.strptime()实现您自己的时间戳解析函数来返回格式和datetime对象是相当简单的，但是针对一系列广泛有用的可能的时间戳格式来高效地执行它却并非如此。|2552595|下面的示例使用了一个略多于50个格式的列表，这些格式是从快速搜索时间戳格式的热门搜索结果之一改编而来的。它甚至没有触及dateutil所解析的各种格式的皮毛。它按顺序测试每种格式，直到找到匹配项或耗尽列表中的所有格式(效率可能比@alecxe的答案中提到的单独定位各个datetime部分的dateutil方法低得多)。|2552596|此外，我还包含了一些包含时区名称(而不是偏移量)的示例时间戳格式。如果您对这些特定的日期时间字符串运行下面的示例函数，您可能会发现它返回"Unable+to+parse+format“，即使我已经使用%25Z指令包含了匹配的格式。在issue+22377+at+bugs.python.org中可以找到关于使用%25Z处理时区名称的挑战的一些解释(只是为了强调实现您自己的datetime解析函数的另一个重要方面)。|2552597|有了所有这些警告，如果您正在处理一组可管理的潜在格式，实现像下面这样的简单东西可能会得到您需要的东西。|2552598|一个示例函数，它尝试将日期时间字符串与格式列表进行匹配，并返回日期时间对象和匹配的格式：|2552599|from+datetime+import+datetime

def+parse_timestamp(datestring,+formats):
++++for+f+in+formats:
++++++++try:
++++++++++++d+=+datetime.strptime(datestring,+f)
++++++++except:
++++++++++++continue
++++++++return+(d,+f)
++++return+(datestring,+'Unable+to+parse+format')|code-block|syntax|javascript|2552600|改编自Timestamps,+Time+Zones,+Time+Ranges,+and+Date+Formats的示例格式和日期时间字符串|2552601|formats+=+['%25Y-%25m-%25dT%25H:%25M:%25S*%25f%25z','%25Y+%25b+%25d+%25H:%25M:%25S.%25f+%25Z','%25b+%25d+%25H:%25M:%25S+%25z+%25Y','%25d/%25b/%25Y:%25H:%25M:%25S+%25z','%25b+%25d,+%25Y+%25I:%25M:%25S+%25p','%25b+%25d+%25Y+%25H:%25M:%25S','%25b+%25d+%25H:%25M:%25S+%25Y','%25b+%25d+%25H:%25M:%25S+%25z','%25b+%25d+%25H:%25M:%25S','%25Y-%25m-%25dT%25H:%25M:%25S%25z','%25Y-%25m-%25dT%25H:%25M:%25S.%25f%25z','%25Y-%25m-%25d+%25H:%25M:%25S+%25z','%25Y-%25m-%25d+%25H:%25M:%25S%25z','%25Y-%25m-%25d+%25H:%25M:%25S,%25f','%25Y/%25m/%25d*%25H:%25M:%25S','%25Y+%25b+%25d+%25H:%25M:%25S.%25f*%25Z','%25Y+%25b+%25d+%25H:%25M:%25S.%25f','%25Y-%25m-%25d+%25H:%25M:%25S,%25f%25z','%25Y-%25m-%25d+%25H:%25M:%25S.%25f','%25Y-%25m-%25d+%25H:%25M:%25S.%25f%25z','%25Y-%25m-%25dT%25H:%25M:%25S.%25f','%25Y-%25m-%25dT%25H:%25M:%25S','%25Y-%25m-%25dT%25H:%25M:%25S%25Z','%25Y-%25m-%25dT%25H:%25M:%25S.%25f','%25Y-%25m-%25dT%25H:%25M:%25S','%25Y-%25m-%25d*%25H:%25M:%25S:%25f','%25Y-%25m-%25d*%25H:%25M:%25S','%25y-%25m-%25d+%25H:%25M:%25S,%25f+%25z','%25y-%25m-%25d+%25H:%25M:%25S,%25f','%25y-%25m-%25d+%25H:%25M:%25S','%25y/%25m/%25d+%25H:%25M:%25S','%25y%25m%25d+%25H:%25M:%25S','%25Y%25m%25d+%25H:%25M:%25S.%25f','%25m/%25d/%25y*%25H:%25M:%25S','%25m/%25d/%25Y*%25H:%25M:%25S','%25m/%25d/%25Y*%25H:%25M:%25S*%25f','%25m/%25d/%25y+%25H:%25M:%25S+%25z','%25m/%25d/%25Y+%25H:%25M:%25S+%25z','%25H:%25M:%25S','%25H:%25M:%25S.%25f','%25H:%25M:%25S,%25f','%25d/%25b+%25H:%25M:%25S,%25f','%25d/%25b/%25Y:%25H:%25M:%25S','%25d/%25b/%25Y+%25H:%25M:%25S','%25d-%25b-%25Y+%25H:%25M:%25S','%25d-%25b-%25Y+%25H:%25M:%25S.%25f','%25d+%25b+%25Y+%25H:%25M:%25S','%25d+%25b+%25Y+%25H:%25M:%25S*%25f','%25m%25d_%25H:%25M:%25S','%25m%25d_%25H:%25M:%25S.%25f','%25m/%25d/%25Y+%25I:%25M:%25S+%25p:%25f','%25m/%25d/%25Y+%25H:%25M:%25S+%25p']

datestrings+=+['2018-08-20T13:20:10*633%2B0000','2017+Mar+03+05:12:41.211+PDT','Jan+21+18:20:11+%2B0000+2017','19/Apr/2017:06:36:15+-0700','Dec+2,+2017+2:39:58+AM','Jun+09+2018+15:28:14','Apr+20+00:00:35+2010','Sep+28+19:00:00+%2B0000','Mar+16+08:12:04','2017-10-14T22:11:20%2B0000','2017-07-01T14:59:55.711%2B0000','2017-08-19+12:17:55+-0400','2017-08-19+12:17:55-0400','2017-06-26+02:31:29,573','2017/04/12*19:37:50','2018+Apr+13+22:08:13.211*PDT','2017+Mar+10+01:44:20.392','2017-03-10+14:30:12,655%2B0000','2018-02-27+15:35:20.311','2017-03-12+13:11:34.222-0700','2017-07-22T16:28:55.444','2017-09-08T03:13:10','2017-03-12T17:56:22-0700','2017-11-22T10:10:15.455','2017-02-11T18:31:44','2017-10-30*02:47:33:899','2017-07-04*13:23:55','11-02-11+16:47:35,985+%2B0000','10-06-26+02:31:29,573','10-04-19+12:00:17','06/01/22+04:11:05','150423+11:42:35','20150423+11:42:35.173','08/10/11*13:33:56','11/22/2017*05:13:11','05/09/2017*08:22:14*612','04/23/17+04:34:22+%2B0000','10/03/2017+07:29:46+-0700','11:42:35','11:42:35.173','11:42:35,173','23/Apr+11:42:35,173','23/Apr/2017:11:42:35','23/Apr/2017+11:42:35','23-Apr-2017+11:42:35','23-Apr-2017+11:42:35.883','23+Apr+2017+11:42:35','23+Apr+2017+10:32:35*311','0423_11:42:35','0423_11:42:35.883','8/5/2011+3:31:18+AM:234','9/28/2011+2:23:15+PM']|2552602|示例用法：|2552603|print(parse_timestamp(datestrings[0],+formats))
#+OUTPUT
#+(datetime.datetime(2018,+8,+20,+13,+20,+10,+633000,+tzinfo=datetime.timezone.utc),+'%25Y-%25m-%25dT%25H:%25M:%25S*%25f%25z')|2552604|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/771848/alecxe|1|https://bugs.python.org/issue22377|2|https://help.sumologic.com/03Send-Data/Sources/04Reference-Information-for-Sources/Timestamps%252C-Time-Zones%252C-Time-Ranges%252C-and-Date-Formats^0|C|8|0|2|J|0|1N|8|41|8|36|7|0|0|2S|2|49|2|36|U|1|0|0|0|0|3|1H|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|J|3|K|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@$9|1X|A|1Y|1|1Z]]|E|$]]|$1|L|3|M|5|6|7|20|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|21|8|@]|D|@]|E|$]]|$1|P|3|Q|5|R|7|22|8|@]|D|@]|E|$S|T]]|$1|U|3|V|5|6|7|23|8|@]|D|@$9|24|A|25|1|26]]|E|$]]|$1|W|3|X|5|R|7|27|8|@]|D|@]|E|$S|T]]|$1|Y|3|Z|5|6|7|28|8|@]|D|@]|E|$]]|$1|10|3|11|5|R|7|29|8|@]|D|@]|E|$S|T]]|$1|12|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19]]|1A|$5|15|16|17|E|$18|1B]]|1C|$5|15|16|17|E|$18|1D]]]]

I don't know of a way that you can return the parsed format from <code>dateutil</code> (or any other python timestamp parser that I know of).

Implementing your own timestamp parsing function that returns the format along with the datetime object is fairly trivial using <code>datetime.strptime()</code> but doing it efficiently against a broadly useful list of possible timestamp formats is not.

The following example utilizes a list of just over 50 formats adapted from one of the top hits from a quick search for timestamp formats. It does not even scratch the surface of the wide variety of formats parsed by <code>dateutil</code>. It tests each format in sequence until it finds a match or exhausts all formats in the list (likely much less efficient than the <code>dateutil</code> approach of locating the various datetime parts independently as noted in the answer from <a href="https://stackoverflow.com/users/771848/alecxe">@alecxe</a>).

In addition, I have included some example timestamp formats that include time zone names (instead of offsets). If you run the example function below against those particular datetime strings, you may find that it returns "Unable to parse format" even though I have included matching formats using the <code>%Z</code> directive. Some explanation for the challenges with using <code>%Z</code> to handle time zone names can be found in <a href="https://bugs.python.org/issue22377" rel="nofollow noreferrer">issue 22377 at bugs.python.org</a> (just to highlight another non-trivial aspect of implementing your own datetime parsing function).

With all of those caveats, if you are dealing with a manageable set of potential formats, implementing something simple like the below may get you what you need.

Example function that attempts to match a datetime string against a list of formats and return the datetime object along with the matched format:

<pre><code>from datetime import datetime

def parse_timestamp(datestring, formats):
 for f in formats:
 try:
 d = datetime.strptime(datestring, f)
 except:
 continue
 return (d, f)
 return (datestring, 'Unable to parse format')
</code></pre>

Example formats and datetime strings adapted from <a href="https://help.sumologic.com/03Send-Data/Sources/04Reference-Information-for-Sources/Timestamps%2C-Time-Zones%2C-Time-Ranges%2C-and-Date-Formats" rel="nofollow noreferrer">Timestamps, Time Zones, Time Ranges, and Date Formats</a>:

<pre><code>formats = ['%Y-%m-%dT%H:%M:%S*%f%z','%Y %b %d %H:%M:%S.%f %Z','%b %d %H:%M:%S %z %Y','%d/%b/%Y:%H:%M:%S %z','%b %d, %Y %I:%M:%S %p','%b %d %Y %H:%M:%S','%b %d %H:%M:%S %Y','%b %d %H:%M:%S %z','%b %d %H:%M:%S','%Y-%m-%dT%H:%M:%S%z','%Y-%m-%dT%H:%M:%S.%f%z','%Y-%m-%d %H:%M:%S %z','%Y-%m-%d %H:%M:%S%z','%Y-%m-%d %H:%M:%S,%f','%Y/%m/%d*%H:%M:%S','%Y %b %d %H:%M:%S.%f*%Z','%Y %b %d %H:%M:%S.%f','%Y-%m-%d %H:%M:%S,%f%z','%Y-%m-%d %H:%M:%S.%f','%Y-%m-%d %H:%M:%S.%f%z','%Y-%m-%dT%H:%M:%S.%f','%Y-%m-%dT%H:%M:%S','%Y-%m-%dT%H:%M:%S%Z','%Y-%m-%dT%H:%M:%S.%f','%Y-%m-%dT%H:%M:%S','%Y-%m-%d*%H:%M:%S:%f','%Y-%m-%d*%H:%M:%S','%y-%m-%d %H:%M:%S,%f %z','%y-%m-%d %H:%M:%S,%f','%y-%m-%d %H:%M:%S','%y/%m/%d %H:%M:%S','%y%m%d %H:%M:%S','%Y%m%d %H:%M:%S.%f','%m/%d/%y*%H:%M:%S','%m/%d/%Y*%H:%M:%S','%m/%d/%Y*%H:%M:%S*%f','%m/%d/%y %H:%M:%S %z','%m/%d/%Y %H:%M:%S %z','%H:%M:%S','%H:%M:%S.%f','%H:%M:%S,%f','%d/%b %H:%M:%S,%f','%d/%b/%Y:%H:%M:%S','%d/%b/%Y %H:%M:%S','%d-%b-%Y %H:%M:%S','%d-%b-%Y %H:%M:%S.%f','%d %b %Y %H:%M:%S','%d %b %Y %H:%M:%S*%f','%m%d_%H:%M:%S','%m%d_%H:%M:%S.%f','%m/%d/%Y %I:%M:%S %p:%f','%m/%d/%Y %H:%M:%S %p']

datestrings = ['2018-08-20T13:20:10*633+0000','2017 Mar 03 05:12:41.211 PDT','Jan 21 18:20:11 +0000 2017','19/Apr/2017:06:36:15 -0700','Dec 2, 2017 2:39:58 AM','Jun 09 2018 15:28:14','Apr 20 00:00:35 2010','Sep 28 19:00:00 +0000','Mar 16 08:12:04','2017-10-14T22:11:20+0000','2017-07-01T14:59:55.711+0000','2017-08-19 12:17:55 -0400','2017-08-19 12:17:55-0400','2017-06-26 02:31:29,573','2017/04/12*19:37:50','2018 Apr 13 22:08:13.211*PDT','2017 Mar 10 01:44:20.392','2017-03-10 14:30:12,655+0000','2018-02-27 15:35:20.311','2017-03-12 13:11:34.222-0700','2017-07-22T16:28:55.444','2017-09-08T03:13:10','2017-03-12T17:56:22-0700','2017-11-22T10:10:15.455','2017-02-11T18:31:44','2017-10-30*02:47:33:899','2017-07-04*13:23:55','11-02-11 16:47:35,985 +0000','10-06-26 02:31:29,573','10-04-19 12:00:17','06/01/22 04:11:05','150423 11:42:35','20150423 11:42:35.173','08/10/11*13:33:56','11/22/2017*05:13:11','05/09/2017*08:22:14*612','04/23/17 04:34:22 +0000','10/03/2017 07:29:46 -0700','11:42:35','11:42:35.173','11:42:35,173','23/Apr 11:42:35,173','23/Apr/2017:11:42:35','23/Apr/2017 11:42:35','23-Apr-2017 11:42:35','23-Apr-2017 11:42:35.883','23 Apr 2017 11:42:35','23 Apr 2017 10:32:35*311','0423_11:42:35','0423_11:42:35.883','8/5/2011 3:31:18 AM:234','9/28/2011 2:23:15 PM']
</code></pre>

Example usage:

<pre><code>print(parse_timestamp(datestrings[0], formats))
# OUTPUT
# (datetime.datetime(2018, 8, 20, 13, 20, 10, 633000, tzinfo=datetime.timezone.utc), '%Y-%m-%dT%H:%M:%S*%f%z')
</code></pre>

blocks|key|2341801|text|我的想法是创建一个类似这样的类，可能并不准确|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2341802|from+datetime+import+datetime
import+re
class+DateTime(object):
++++dateFormat+=+{"%25d":+"dd",+"%25Y":+"YYYY",+"%25a":+"Day",+"%25A":+"DAY",+"%25w":+"ww",+"%25b":+"Mon",+"%25B":+"MON",+"%25m":+"mm",
++++++++++++++++++"%25H":+"HH",+"%25I":+"II",+"%25p":+"pp",+"%25M":+"MM",+"%25S":+"SS"}++#+wil+contain+all+format+equivalent

++++def+__init__(self,+date_str,+format):
++++++++self.dateobj+=+datetime.strptime(date_str,+format)
++++++++self.format+=+format

++++def+parse_format(self):
++++++++output=None
++++++++reg+=+re.compile("%25[A-Z+a-z]")
++++++++fmts+=+None
++++++++if+self.format+is+not+None:
++++++++++++fmts+=+re.findall(reg,+self.format)
++++++++if+fmts+is+not+None:
++++++++++++output+=+self.format
++++++++++++for+f+in+fmts:
++++++++++++++++output+=+output.replace(f,+DateTime.dateFormat[f])
++++++++return+output


nDate+=+DateTime("12+January,+2018",+"%25d+%25B,+%25Y")
print(nDate.parse_format())|code-block|syntax|javascript|2341803|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My idea was to create a class something like this, might not be accurate 

<pre><code>from datetime import datetime
import re
class DateTime(object):
 dateFormat = {"%d": "dd", "%Y": "YYYY", "%a": "Day", "%A": "DAY", "%w": "ww", "%b": "Mon", "%B": "MON", "%m": "mm",
 "%H": "HH", "%I": "II", "%p": "pp", "%M": "MM", "%S": "SS"} # wil contain all format equivalent

 def __init__(self, date_str, format):
 self.dateobj = datetime.strptime(date_str, format)
 self.format = format

 def parse_format(self):
 output=None
 reg = re.compile("%[A-Z a-z]")
 fmts = None
 if self.format is not None:
 fmts = re.findall(reg, self.format)
 if fmts is not None:
 output = self.format
 for f in fmts:
 output = output.replace(f, DateTime.dateFormat[f])
 return output


nDate = DateTime("12 January, 2018", "%d %B, %Y")
print(nDate.parse_format())
</code></pre>

blocks|key|2552724|text|我的想法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2552725|2552726|创建一个对象，其中包含您认为可能在日期模式中的候选说明符的列表(添加的越多，从另一端获得的可能性就越大)|ordered-list-item|2552727|解析日期字符串|2552728|根据日期和候选人列表，为字符串中的每个元素创建可能的说明符的列表，以生成可能的说明符的列表。|2552729|2552730|如果你只有一个候选人，你可以非常确定它的格式是正确的。但你通常会得到许多可能性(特别是日期，月，分钟和小时都在0-10的范围内)。|2552731|示例类：|2552732|import+re
from+itertools+import+product
from+dateutil.parser+import+parse
from+collections+import+defaultdict,+Counter

COMMON_SPECIFIERS+=+[
++++'%25a',+'%25A',+'%25d',+'%25b',+'%25B',+'%25m',
++++'%25Y',+'%25H',+'%25p',+'%25M',+'%25S',+'%25Z',
]


class+FormatFinder:
++++def+__init__(self,
+++++++++++++++++valid_specifiers=COMMON_SPECIFIERS,
+++++++++++++++++date_element=r'([\w]%2B)',
+++++++++++++++++delimiter_element=r'([\W]%2B)',
+++++++++++++++++ignore_case=False):
++++++++self.specifiers+=+valid_specifiers
++++++++joined+=+(r''+%2B+date_element+%2B+r"%7C"+%2B+delimiter_element)
++++++++self.pattern+=+re.compile(joined)
++++++++self.ignore_case+=+ignore_case

++++def+find_candidate_patterns(self,+date_string):
++++++++date+=+parse(date_string)
++++++++tokens+=+self.pattern.findall(date_string)

++++++++candidate_specifiers+=+defaultdict(list)

++++++++for+specifier+in+self.specifiers:
++++++++++++token+=+date.strftime(specifier)
++++++++++++candidate_specifiers[token].append(specifier)
++++++++++++if+self.ignore_case:
++++++++++++++++candidate_specifiers[token.
+++++++++++++++++++++++++++++++++++++upper()]+=+candidate_specifiers[token]
++++++++++++++++candidate_specifiers[token.
+++++++++++++++++++++++++++++++++++++lower()]+=+candidate_specifiers[token]

++++++++options_for_each_element+=+[]
++++++++for+(token,+delimiter)+in+tokens:
++++++++++++if+token:
++++++++++++++++if+token+not+in+candidate_specifiers:
++++++++++++++++++++options_for_each_element.append(
++++++++++++++++++++++++[token])++#+just+use+this+verbatim?
++++++++++++++++else:
++++++++++++++++++++options_for_each_element.append(
++++++++++++++++++++++++candidate_specifiers[token])
++++++++++++else:
++++++++++++++++options_for_each_element.append([delimiter])

++++++++for+parts+in+product(*options_for_each_element):
++++++++++++counts+=+Counter(parts)
++++++++++++max_count+=+max(counts[specifier]+for+specifier+in+self.specifiers)
++++++++++++if+max_count+>+1:
++++++++++++++++#+this+is+a+candidate+with+the+same+item+used+more+than+once
++++++++++++++++continue
++++++++++++yield+"".join(parts)|code-block|syntax|javascript|2552733|和一些示例测试：|2552734|def+test_it_returns_value_from_question_1():
++++s+=+"2014-01-01+00:12:12"
++++candidates+=+FormatFinder().find_candidate_patterns(s)
++++sut+=+FormatFinder()
++++candidates+=+sut.find_candidate_patterns(s)
++++assert+"%25Y-%25m-%25d+%25H:%25M:%25S"+in+candidates


def+test_it_returns_value_from_question_2():
++++s+=+'Jan.+04,+2017'
++++sut+=+FormatFinder()
++++candidates+=+sut.find_candidate_patterns(s)
++++candidates+=+list(candidates)
++++assert+"%25b.+%25d,+%25Y"+in+candidates
++++assert+len(candidates)+==+1


def+test_it_can_ignore_case():
++++#+NB:+apparently+the+'AM/PM'+is+meant+to+be+capitalised+in+my+locale!+
++++#+News+to+me!
++++s+=+"JANUARY+12,+2018+02:12+am"
++++sut+=+FormatFinder(ignore_case=True)
++++candidates+=+sut.find_candidate_patterns(s)
++++assert+"%25B+%25d,+%25Y+%25H:%25M+%25p"+in+candidates


def+test_it_returns_parts_that_have_no_date_component_verbatim():
++++#+In+this+string,+the+'at'+is+considered+as+a+'date'+element,+
++++#+but+there+is+no+specifier+that+produces+a+candidate+for+it
++++s+=+"January+12,+2018+at+02:12+AM"
++++sut+=+FormatFinder()
++++candidates+=+sut.find_candidate_patterns(s)
++++assert+"%25B+%25d,+%25Y+at+%25H:%25M+%25p"+in+candidates|2552735|为了更清楚，这里有一些在iPython外壳中使用此代码的示例：|2552736|In+[2]:+ff+=+FormatFinder()

In+[3]:+list(ff.find_candidate_patterns("2014-01-01+00:12:12"))
Out[3]:
['%25Y-%25d-%25m+%25H:%25M:%25S',
+'%25Y-%25d-%25m+%25H:%25S:%25M',
+'%25Y-%25m-%25d+%25H:%25M:%25S',
+'%25Y-%25m-%25d+%25H:%25S:%25M']

In+[4]:+list(ff.find_candidate_patterns("Jan.+04,+2017"))
Out[4]:+['%25b.+%25d,+%25Y']

In+[5]:+list(ff.find_candidate_patterns("January+12,+2018+at+02:12+AM"))
Out[5]:+['%25B+%25d,+%25Y+at+%25H:%25M+%25p',+'%25B+%25M,+%25Y+at+%25H:%25d+%25p']

In+[6]:+ff_without_case+=+FormatFinder(ignore_case=True)

In+[7]:+list(ff_without_case.find_candidate_patterns("JANUARY+12,+2018+02:12+am"))
Out[7]:+['%25B+%25d,+%25Y+%25H:%25M+%25p',+'%25B+%25M,+%25Y+%25H:%25d+%25p']|2552737|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|15|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|16|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|17|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1B|8|@]|9|@]|A|$R|S]]|$1|T|3|U|5|6|7|1C|8|@]|9|@]|A|$]]|$1|V|3|W|5|Q|7|1D|8|@]|9|@]|A|$R|S]]|$1|X|3|Y|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Z|3|10|5|Q|7|1F|8|@]|9|@]|A|$R|S]]|$1|11|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|12|$]]

My idea was to:

<ol>
<li>Create an object that has a list of candidate specifiers you think might be in the date pattern (the more you add, the more possibilities you will get out the other end)</li>
<li>Parse the date string</li>
<li>Create a list of possible specifiers for each element in the string, based on the date and the list of candidates you supplied.</li>
<li>Recombine them to produce a list of 'possibles'.</li>
</ol>

If you get only a single candidate, you can be pretty sure is it the right format. But you will often get many possibilities (especially with dates, months, minutes and hours all in the 0-10 range).

Example class:

<pre><code>import re
from itertools import product
from dateutil.parser import parse
from collections import defaultdict, Counter

COMMON_SPECIFIERS = [
 '%a', '%A', '%d', '%b', '%B', '%m',
 '%Y', '%H', '%p', '%M', '%S', '%Z',
]


class FormatFinder:
 def __init__(self,
 valid_specifiers=COMMON_SPECIFIERS,
 date_element=r'([\w]+)',
 delimiter_element=r'([\W]+)',
 ignore_case=False):
 self.specifiers = valid_specifiers
 joined = (r'' + date_element + r"|" + delimiter_element)
 self.pattern = re.compile(joined)
 self.ignore_case = ignore_case

 def find_candidate_patterns(self, date_string):
 date = parse(date_string)
 tokens = self.pattern.findall(date_string)

 candidate_specifiers = defaultdict(list)

 for specifier in self.specifiers:
 token = date.strftime(specifier)
 candidate_specifiers[token].append(specifier)
 if self.ignore_case:
 candidate_specifiers[token.
 upper()] = candidate_specifiers[token]
 candidate_specifiers[token.
 lower()] = candidate_specifiers[token]

 options_for_each_element = []
 for (token, delimiter) in tokens:
 if token:
 if token not in candidate_specifiers:
 options_for_each_element.append(
 [token]) # just use this verbatim?
 else:
 options_for_each_element.append(
 candidate_specifiers[token])
 else:
 options_for_each_element.append([delimiter])

 for parts in product(*options_for_each_element):
 counts = Counter(parts)
 max_count = max(counts[specifier] for specifier in self.specifiers)
 if max_count &gt; 1:
 # this is a candidate with the same item used more than once
 continue
 yield "".join(parts)
</code></pre>

And some sample tests:

<pre><code>def test_it_returns_value_from_question_1():
 s = "2014-01-01 00:12:12"
 candidates = FormatFinder().find_candidate_patterns(s)
 sut = FormatFinder()
 candidates = sut.find_candidate_patterns(s)
 assert "%Y-%m-%d %H:%M:%S" in candidates


def test_it_returns_value_from_question_2():
 s = 'Jan. 04, 2017'
 sut = FormatFinder()
 candidates = sut.find_candidate_patterns(s)
 candidates = list(candidates)
 assert "%b. %d, %Y" in candidates
 assert len(candidates) == 1


def test_it_can_ignore_case():
 # NB: apparently the 'AM/PM' is meant to be capitalised in my locale! 
 # News to me!
 s = "JANUARY 12, 2018 02:12 am"
 sut = FormatFinder(ignore_case=True)
 candidates = sut.find_candidate_patterns(s)
 assert "%B %d, %Y %H:%M %p" in candidates


def test_it_returns_parts_that_have_no_date_component_verbatim():
 # In this string, the 'at' is considered as a 'date' element, 
 # but there is no specifier that produces a candidate for it
 s = "January 12, 2018 at 02:12 AM"
 sut = FormatFinder()
 candidates = sut.find_candidate_patterns(s)
 assert "%B %d, %Y at %H:%M %p" in candidates
</code></pre>

To make it a bit clearer, here's some example of using this code in an iPython shell:

<pre><code>In [2]: ff = FormatFinder()

In [3]: list(ff.find_candidate_patterns("2014-01-01 00:12:12"))
Out[3]:
['%Y-%d-%m %H:%M:%S',
 '%Y-%d-%m %H:%S:%M',
 '%Y-%m-%d %H:%M:%S',
 '%Y-%m-%d %H:%S:%M']

In [4]: list(ff.find_candidate_patterns("Jan. 04, 2017"))
Out[4]: ['%b. %d, %Y']

In [5]: list(ff.find_candidate_patterns("January 12, 2018 at 02:12 AM"))
Out[5]: ['%B %d, %Y at %H:%M %p', '%B %M, %Y at %H:%d %p']

In [6]: ff_without_case = FormatFinder(ignore_case=True)

In [7]: list(ff_without_case.find_candidate_patterns("JANUARY 12, 2018 02:12 am"))
Out[7]: ['%B %d, %Y %H:%M %p', '%B %M, %Y %H:%d %p']
</code></pre>

blocks|key|2342144|text|想法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2342145|2342146|检查用户输入的日期字符串，并构建可能的日期格式集|ordered-list-item|2342147|循环在格式集上，使用datetime.strptime分析具有个别可能日期格式的日期字符串。|offset|length|style|CODE|2342148|使用datetime.strftime格式化步骤2中的日期，如果结果等于原始日期字符串，则此格式可能是日期格式。|2342149|2342150|算法实现|2342151|from+datetime+import+datetime
import+itertools
import+re

FORMAT_CODES+=+(
++++r'%25a',+r'%25A',+r'%25w',+r'%25d',+r'%25b',+r'%25B',+r'%25m',+r'%25y',+r'%25Y',
++++r'%25H',+r'%25I',+r'%25p',+r'%25M',+r'%25S',+r'%25f',+r'%25z',+r'%25Z',+r'%25j',
++++r'%25U',+r'%25W',
)

TWO_LETTERS_FORMATS+=+(
++++r'%25p',
)

THREE_LETTERS_FORMATS+=+(
++++r'%25a',+r'%25b'
)

LONG_LETTERS_FORMATS+=+(
++++r'%25A',+r'%25B',+r'%25z',+r'%25Z',
)

SINGLE_DIGITS_FORMATS+=+(
++++r'w',
)

TWO_DIGITS_FORMATS+=+(
++++r'%25d',+r'%25m',+r'%25y',+r'%25H',+r'%25I',+r'%25M',+r'%25S',+r'%25U',+r'%25W',
)

THREE_DIGITS_FORMATS+=+(
++++r'%25j',
)

FOUR_DIGITS_FORMATS+=+(
++++r'%25Y',
)

LONG_DIGITS_FORMATS+=+(
++++r'%25f',
)

#+Non+format+code+symbols
SYMBOLS+=+(
++++'-',
++++':',
++++'%2B',
++++'Z',
++++',',
++++'+',
)


if+__name__+==+'__main__':
++++date_str+=+input('Please+input+a+date:+')

++++#+Split+with+non+format+code+symbols
++++pattern+=+r'[%5E{}]%2B'.format(''.join(SYMBOLS))
++++components+=+re.findall(pattern,+date_str)

++++#+Create+a+format+placeholder,+eg.+'{}-{}-{}+{}:{}:{}%2B{}'
++++placeholder+=+re.sub(pattern,+'{}',+date_str)

++++formats+=+[]
++++for+comp+in+components:
++++++++if+re.match(r'%5E\d{1}$',+comp):
++++++++++++formats.append(SINGLE_DIGITS_FORMATS)
++++++++elif+re.match(r'%5E\d{2}$',+comp):
++++++++++++formats.append(TWO_DIGITS_FORMATS)
++++++++elif+re.match(r'%5E\d{3}$',+comp):
++++++++++++formats.append(THREE_DIGITS_FORMATS)
++++++++elif+re.match(r'%5E\d{4}$',+comp):
++++++++++++formats.append(FOUR_DIGITS_FORMATS)
++++++++elif+re.match(r'%5E\d{5,}$',+comp):
++++++++++++formats.append(LONG_DIGITS_FORMATS)
++++++++elif+re.match(r'%5E[a-zA-Z]{2}$',+comp):
++++++++++++formats.append(TWO_LETTERS_FORMATS)
++++++++elif+re.match(r'%5E[a-zA-Z]{3}$',+comp):
++++++++++++formats.append(THREE_LETTERS_FORMATS)
++++++++elif+re.match(r'%5E[a-zA-Z]{4,}$',+comp):
++++++++++++formats.append(LONG_LETTERS_FORMATS)
++++++++else:
++++++++++++formats.append(FORMAT_CODES)

++++#+Create+a+possible+format+set
++++possible_set+=+itertools.product(*formats)

++++found+=+0
++++for+possible_format+in+possible_set:
++++++++#+Create+a+format+with+possible+format+combination
++++++++dt_format+=+placeholder.format(*possible_format)
++++++++try:
++++++++++++dt+=+datetime.strptime(date_str,+dt_format)
++++++++++++#+Use+the+format+to+parse+the+date,+and+format+the+
++++++++++++#+date+back+to+string+and+compare+with+the+origin+one
++++++++++++if+dt.strftime(dt_format)+==+date_str:
++++++++++++++++print('Possible+result:+{}'.format(dt_format))
++++++++++++++++found+%2B=+1
++++++++except+Exception:
++++++++++++continue

++++if+found+==+0:
++++++++print('No+pattern+found')|code-block|syntax|javascript|2342152|用法：|2342153|$+python3+reverse.py
Please+input+a+date:+2018-12-31+10:26+PM
Possible+result:+%25Y-%25d-%25M+%25I:%25S+%25p
Possible+result:+%25Y-%25d-%25S+%25I:%25M+%25p
Possible+result:+%25Y-%25m-%25d+%25I:%25M+%25p
Possible+result:+%25Y-%25m-%25d+%25I:%25S+%25p
Possible+result:+%25Y-%25m-%25M+%25I:%25d+%25p
Possible+result:+%25Y-%25m-%25M+%25I:%25S+%25p
Possible+result:+%25Y-%25m-%25S+%25I:%25d+%25p
Possible+result:+%25Y-%25m-%25S+%25I:%25M+%25p
Possible+result:+%25Y-%25H-%25d+%25m:%25M+%25p
Possible+result:+%25Y-%25H-%25d+%25m:%25S+%25p
Possible+result:+%25Y-%25H-%25d+%25M:%25S+%25p
Possible+result:+%25Y-%25H-%25d+%25S:%25M+%25p
Possible+result:+%25Y-%25H-%25M+%25d:%25S+%25p
Possible+result:+%25Y-%25H-%25M+%25m:%25d+%25p
Possible+result:+%25Y-%25H-%25M+%25m:%25S+%25p
Possible+result:+%25Y-%25H-%25M+%25S:%25d+%25p
Possible+result:+%25Y-%25H-%25S+%25d:%25M+%25p
Possible+result:+%25Y-%25H-%25S+%25m:%25d+%25p
Possible+result:+%25Y-%25H-%25S+%25m:%25M+%25p
Possible+result:+%25Y-%25H-%25S+%25M:%25d+%25p
Possible+result:+%25Y-%25I-%25d+%25m:%25M+%25p
Possible+result:+%25Y-%25I-%25d+%25m:%25S+%25p
Possible+result:+%25Y-%25I-%25d+%25M:%25S+%25p
Possible+result:+%25Y-%25I-%25d+%25S:%25M+%25p
Possible+result:+%25Y-%25I-%25M+%25d:%25S+%25p
Possible+result:+%25Y-%25I-%25M+%25m:%25d+%25p
Possible+result:+%25Y-%25I-%25M+%25m:%25S+%25p
Possible+result:+%25Y-%25I-%25M+%25S:%25d+%25p
Possible+result:+%25Y-%25I-%25S+%25d:%25M+%25p
Possible+result:+%25Y-%25I-%25S+%25m:%25d+%25p
Possible+result:+%25Y-%25I-%25S+%25m:%25M+%25p
Possible+result:+%25Y-%25I-%25S+%25M:%25d+%25p
Possible+result:+%25Y-%25M-%25d+%25I:%25S+%25p
Possible+result:+%25Y-%25M-%25S+%25I:%25d+%25p
Possible+result:+%25Y-%25S-%25d+%25I:%25M+%25p
Possible+result:+%25Y-%25S-%25M+%25I:%25d+%25p|2342154|entityMap^0|0|0|0|A|H|0|2|H|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|14|8|@$H|15|I|16|J|K]]|9|@]|A|$]]|$1|L|3|M|5|E|7|17|8|@$H|18|I|19|J|K]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1C|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1D|8|@]|9|@]|A|$]]|$1|X|3|Y|5|S|7|1E|8|@]|9|@]|A|$T|U]]|$1|Z|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|10|$]]

<h2>Idea:</h2>

<ol>
<li>Inspect the user input date string, and build possible date format set</li>
<li>Loop over the format set, use <code>datetime.strptime</code> parse the date string with individual possible date format.</li>
<li>Format the date from step 2 with <code>datetime.strftime</code>, if the result equal to the origin date string, then this format is a possible date format.</li>
</ol>

<h2>Algorithm implementation</h2>

<pre><code>from datetime import datetime
import itertools
import re

FORMAT_CODES = (
 r'%a', r'%A', r'%w', r'%d', r'%b', r'%B', r'%m', r'%y', r'%Y',
 r'%H', r'%I', r'%p', r'%M', r'%S', r'%f', r'%z', r'%Z', r'%j',
 r'%U', r'%W',
)

TWO_LETTERS_FORMATS = (
 r'%p',
)

THREE_LETTERS_FORMATS = (
 r'%a', r'%b'
)

LONG_LETTERS_FORMATS = (
 r'%A', r'%B', r'%z', r'%Z',
)

SINGLE_DIGITS_FORMATS = (
 r'w',
)

TWO_DIGITS_FORMATS = (
 r'%d', r'%m', r'%y', r'%H', r'%I', r'%M', r'%S', r'%U', r'%W',
)

THREE_DIGITS_FORMATS = (
 r'%j',
)

FOUR_DIGITS_FORMATS = (
 r'%Y',
)

LONG_DIGITS_FORMATS = (
 r'%f',
)

# Non format code symbols
SYMBOLS = (
 '-',
 ':',
 '+',
 'Z',
 ',',
 ' ',
)


if __name__ == '__main__':
 date_str = input('Please input a date: ')

 # Split with non format code symbols
 pattern = r'[^{}]+'.format(''.join(SYMBOLS))
 components = re.findall(pattern, date_str)

 # Create a format placeholder, eg. '{}-{}-{} {}:{}:{}+{}'
 placeholder = re.sub(pattern, '{}', date_str)

 formats = []
 for comp in components:
 if re.match(r'^\d{1}$', comp):
 formats.append(SINGLE_DIGITS_FORMATS)
 elif re.match(r'^\d{2}$', comp):
 formats.append(TWO_DIGITS_FORMATS)
 elif re.match(r'^\d{3}$', comp):
 formats.append(THREE_DIGITS_FORMATS)
 elif re.match(r'^\d{4}$', comp):
 formats.append(FOUR_DIGITS_FORMATS)
 elif re.match(r'^\d{5,}$', comp):
 formats.append(LONG_DIGITS_FORMATS)
 elif re.match(r'^[a-zA-Z]{2}$', comp):
 formats.append(TWO_LETTERS_FORMATS)
 elif re.match(r'^[a-zA-Z]{3}$', comp):
 formats.append(THREE_LETTERS_FORMATS)
 elif re.match(r'^[a-zA-Z]{4,}$', comp):
 formats.append(LONG_LETTERS_FORMATS)
 else:
 formats.append(FORMAT_CODES)

 # Create a possible format set
 possible_set = itertools.product(*formats)

 found = 0
 for possible_format in possible_set:
 # Create a format with possible format combination
 dt_format = placeholder.format(*possible_format)
 try:
 dt = datetime.strptime(date_str, dt_format)
 # Use the format to parse the date, and format the 
 # date back to string and compare with the origin one
 if dt.strftime(dt_format) == date_str:
 print('Possible result: {}'.format(dt_format))
 found += 1
 except Exception:
 continue

 if found == 0:
 print('No pattern found')
</code></pre>

<h2>Usage:</h2>

<pre><code>$ python3 reverse.py
Please input a date: 2018-12-31 10:26 PM
Possible result: %Y-%d-%M %I:%S %p
Possible result: %Y-%d-%S %I:%M %p
Possible result: %Y-%m-%d %I:%M %p
Possible result: %Y-%m-%d %I:%S %p
Possible result: %Y-%m-%M %I:%d %p
Possible result: %Y-%m-%M %I:%S %p
Possible result: %Y-%m-%S %I:%d %p
Possible result: %Y-%m-%S %I:%M %p
Possible result: %Y-%H-%d %m:%M %p
Possible result: %Y-%H-%d %m:%S %p
Possible result: %Y-%H-%d %M:%S %p
Possible result: %Y-%H-%d %S:%M %p
Possible result: %Y-%H-%M %d:%S %p
Possible result: %Y-%H-%M %m:%d %p
Possible result: %Y-%H-%M %m:%S %p
Possible result: %Y-%H-%M %S:%d %p
Possible result: %Y-%H-%S %d:%M %p
Possible result: %Y-%H-%S %m:%d %p
Possible result: %Y-%H-%S %m:%M %p
Possible result: %Y-%H-%S %M:%d %p
Possible result: %Y-%I-%d %m:%M %p
Possible result: %Y-%I-%d %m:%S %p
Possible result: %Y-%I-%d %M:%S %p
Possible result: %Y-%I-%d %S:%M %p
Possible result: %Y-%I-%M %d:%S %p
Possible result: %Y-%I-%M %m:%d %p
Possible result: %Y-%I-%M %m:%S %p
Possible result: %Y-%I-%M %S:%d %p
Possible result: %Y-%I-%S %d:%M %p
Possible result: %Y-%I-%S %m:%d %p
Possible result: %Y-%I-%S %m:%M %p
Possible result: %Y-%I-%S %M:%d %p
Possible result: %Y-%M-%d %I:%S %p
Possible result: %Y-%M-%S %I:%d %p
Possible result: %Y-%S-%d %I:%M %p
Possible result: %Y-%S-%M %I:%d %p
</code></pre>

blocks|key|2342426|text|您可以对函数进行包装，以便在调用包装的版本时将参数与结果一起存储：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2342427|from+dateutil.parser+import+parse
from+functools+import+wraps

def+parse_wrapper(function):
++++@wraps(function)
++++def+wrapper(*args):
++++++++return+{'datetime':+function(*args),+'args':+args}
++++return+wrapper

wrapped_parse+=+parse_wrapper(parse)
x+=+wrapped_parse("2014-01-01+00:12:12")
#+{'datetime':+datetime.datetime(2014,+1,+1,+0,+12,+12),
#++'args':+('2014-01-01+00:12:12',)}|code-block|syntax|javascript|2342428|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can wrap the function to store the arguments along with the result any time you call the wrapped version:

<pre><code>from dateutil.parser import parse
from functools import wraps

def parse_wrapper(function):
 @wraps(function)
 def wrapper(*args):
 return {'datetime': function(*args), 'args': args}
 return wrapper

wrapped_parse = parse_wrapper(parse)
x = wrapped_parse("2014-01-01 00:12:12")
# {'datetime': datetime.datetime(2014, 1, 1, 0, 12, 12),
# 'args': ('2014-01-01 00:12:12',)}
</code></pre>

Is there a way to get the "format" after parsing a date in dateutil. For example something like:

<pre><code>&gt;&gt;&gt; x = parse("2014-01-01 00:12:12")
datetime.datetime(2014, 1, 1, 0, 12, 12)

x.get_original_string_format()
YYYY-MM-DD HH:MM:SS # %Y-%m-%d %H:%M:%S

# Or, passing the date-string directly
get_original_string_format("2014-01-01 00:12:12")
YYYY-MM-DD HH:MM:SS # %Y-%m-%d %H:%M:%S
</code></pre>

<hr>

Update: I'd like to add a bounty to this question to see if someone could add an answer that would do the equivalent on getting the string-format of a common date-string passed. It can use <code>dateutil</code> if you want, but it doesn't have to. Hopefully we'll get some creative solutions here.

Get the format in dateutil.parse

有没有办法在分析dateutil中的日期后获得“格式”？例如，如下所示：>>> x = parse("2014-01-01 00:12:12")datetime.datetime(2014, 1, 1, 0, 12, 12)x.get_original_string_format()YYYY-MM-DD HH:MM:S...

问获取dateutil.parse格式
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取dateutil.parse格式EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取dateutil.parse格式
EN