Fixed the weird syntax highlighting (as a result, the diff looks more extensive than it really is - use view "Side-by-side Markdown" to compare) - an alternative would be to separate the code from the output.
Peter Mortensen
- 31.3k
- 22
- 110
- 134
It seems using pandas Timestamp is the fastest:
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is an ISO 8601 string, please use csio8601:
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
It seems using pandas Timestamp is the fastest:
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is an ISO 8601 string, please use csio8601:
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
It seems using pandas Timestamp is the fastest:
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is an ISO 8601 string, please use csio8601:
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Active reading [<https://en.wikipedia.org/wiki/ISO_8601> <https://www.youtube.com/watch?v=1Dax90QyXgI&t=17m54s>]. Removed unnecessary formatting.
Peter Mortensen
- 31.3k
- 22
- 110
- 134
It seems using pandas Timestamp is the fastest It seems using pandas Timestamp is the fastest:
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is ISO8601 string please use csio8601 If the string is an ISO 8601 string, please use csio8601 :
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
It seems using pandas Timestamp is the fastest
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is ISO8601 string please use csio8601
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
It seems using pandas Timestamp is the fastest:
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is an ISO 8601 string, please use csio8601 :
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
It seems using pandaspandas Timestamp is the fastest
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(map(lambda x: x.date(), pd.to_datetime(l, format=format)))
%timeit _ = list(map(lambda x: x.date(), pd.to_datetime(l, format=format)))
1.7458 ms ± 1621.96 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format).date(), l))
9.441 ms ± 9995.27 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x).date(), l))
7273.98 ms ± 6301.14 μsms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is ISO8601 string please use csio8601
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x).date(), l))
244186 μs ± 34.613 μs per loop (mean ± std. dev. of 7 runs, 100010000 loops each)
It seems using pandas is the fastest
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(map(lambda x: x.date(), pd.to_datetime(l, format=format)))
%timeit _ = list(map(lambda x: x.date(), pd.to_datetime(l, format=format)))
1.74 ms ± 16.9 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
%timeit _ = list(map(lambda x: datetime.strptime(x, format).date(), l))
9.4 ms ± 99.2 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit _ = list(map(lambda x: parse(x).date(), l))
72.9 ms ± 630 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is ISO8601 string please use csio8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x).date(), l))
244 μs ± 3.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
It seems using pandas Timestamp is the fastest
import pandas as pd
N = 1000
l = ['Jun 1 2005 1:33PM'] * N
list(pd.to_datetime(l, format=format))
%timeit _ = list(pd.to_datetime(l, format=format))
1.58 ms ± 21.6 μs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Other solutions
from datetime import datetime
%timeit _ = list(map(lambda x: datetime.strptime(x, format), l))
9.41 ms ± 95.7 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
from dateutil.parser import parse
%timeit _ = list(map(lambda x: parse(x), l))
73.8 ms ± 1.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
If the string is ISO8601 string please use csio8601
import ciso8601
l = ['2014-01-09'] * N
%timeit _ = list(map(lambda x: ciso8601.parse_datetime(x), l))
186 μs ± 4.13 μs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
lang-py