How would I go about converting a float like 3.65 into 4 mins 5 seconds.
I have tried using:
print(datetime.datetime.strptime('3.35','%M%-S'))
However, I get this back:
ValueError: '-' is a bad directive in format '%-M:%-S'
Take a look at the following script, you can figure out how to make it work for days years, etc, this only works if we assume the format is "hours.minutes"
import datetime
# Assuming the 3 represents the hours and the 0.65 the minutes
number = 3.65
# First, we need to split the numbero into its whole decimal part
# and its decimal part
whole_decimal_part = hours = int(number) # 3
decimal_part = number % whole_decimal_part # 0.6499999
# Now, we need to know how many extra hours are in the decimal part
extra_hours = round((decimal_part * 100) / 60) # 1
minutes = round((decimal_part * 100) % 60) # 5
hours += extra_hours # 4
time_str = "%(hours)s:%(minutes)s" % {
"hours": hours,
"minutes": minutes
} # 4:5
final_time = datetime.datetime.strptime(time_str, "%H:%M").time()
print(final_time) # 04:05:00
First, you should complain to whoever is giving you time data expressed like that.
If you need to process minutes and seconds as a standalone value, then the datetime object may not your best choice either.
If you still need to convert "3.65" into a datetime object corresponding to "4-05" you could adjust it to be a valid time representation before passing it to strptime()
m,s = map(int,"3.65".split("."))
m,s = (m+s)//60,s%60
dt = datetime.datetime.strptime(f"{m}-{s}","%M%-S")
Split your time into minute and seconds
If seconds is 60 or more, then add extra minutes (//) ; second is the modulo (%)
t="3.65"
m, s = [int(i) for i in t.split('.')]
if s >= 60:
m += s//60
s = s % 60
print(f'{m} mins {s} seconds') # -> 4 mins 5 seconds
while 65 seconds cannot be parsed correctly so you have to manipulate by yourself to clean the data first before parsing.
NOTE: assuming seconds is not a very very big number which can make minutes>60
import datetime
time= '3.65'
split_time = time.split(".")
minute =int(split_time[0])
seconds = int(split_time[1])
minute_offset, seconds = divmod(seconds, 60);
minute = int(split_time[0]) + minute_offset
print(datetime.datetime.strptime('{}.{}'.format(minute,seconds),'%M.%S')) #1900-01-01 00:04:05
You can alternatively use .time() on datetime object to extract the time
print(datetime.datetime.strptime('{}.{}'.format(minute,seconds),'%M.%S').time()) #00:04:05
A much cleaner and safer solution is (to consider hour as well). Convert everything into seconds and then convert back to hours, minutes, seconds
def convert(seconds):
min, sec = divmod(seconds, 60)
hour, min = divmod(min, 60)
return "%d:%02d:%02d" % (hour, min, sec)
time='59.65'
split_time = time.split(".")
minute =int(split_time[0])
seconds = int(split_time[1])
new_seconds = minute*60 +65
datetime.datetime.strptime(convert(new_seconds),'%H:%M:%S').time()
Related
I've values in float and I am trying to convert them into Hours:Min:Seconds but I've failed. I've followed the following post:
Converting a float to hh:mm format
For example I've got a value in float format:
time=0.6
result = '{0:02.0f}:{1:02.0f}'.format(*divmod(time * 60, 60))
and it gives me the output:
00:36
But actually it should be like "00:00:36". How do I get this?
You can make use of the datetime module:
import datetime
time = 0.6
result = str(datetime.timedelta(minutes=time))
You're not obtaining the hours from anywhere so you'll first need to extract the hours, i.e.:
float_time = 0.6 # in minutes
hours, seconds = divmod(float_time * 60, 3600) # split to hours and seconds
minutes, seconds = divmod(seconds, 60) # split the seconds to minutes and seconds
Then you can deal with formatting, i.e.:
result = "{:02.0f}:{:02.0f}:{:02.0f}".format(hours, minutes, seconds)
# 00:00:36
Divmod function accepts only two parameter hence you get either of the two
Divmod()
So you can try doing this:
time = 0.6
mon, sec = divmod(time, 60)
hr, mon = divmod(mon, 60)
print "%d:%02d:%02d" % (hr, mon, sec)
I have a timestep (e.g. 2717715 microseconds) which I want to convert to hh:mm:ss format to extract a frame from a youtube video. I have used the following code to do so:
def convert(timestamp):
# pdb.set_trace()
timestamp = float(timestamp)
# seconds = (micros/1000)%60
# minutes = (micros/(1000*60))%60
# hours = (micros/(1000*60*60))%24
# pdb.set_trace
milliseconds = (timestamp / 1000) % 1000
seconds = (( (timestamp / 1000) - milliseconds)/1000)%60
minutes = (((( (timestamp / 1000) - milliseconds)/1000) - seconds)/60) %60
hours = ((((((timestamp / 1000) - milliseconds)/1000) - seconds)/60) - minutes)/60
return hours, minutes, seconds
But it is not working. Can you please tell me what is wrong with my code?
Considering your timestamp is of type float you can use the built in divmod function as follows:
timestamp = 3 * 3600 + 7 * 60 + 20 # just creating (3h 7m 20s) float format timestamp
print(timestamp) # gives 11240
suppose you have that timestamp, you can extract your hours, minutes and seconds from it as follows:
timestamp = float(timestamp)/1000000 # The timestamp is in microseconds
hours,remainder = divmod(timestamp, 3600)
minutes,seconds = divmod(remainder, 60)
print(hours) # gives 3
print(minutes) # gives 7
print(seconds) # gives 20
Hope that helped. Happy Coding.
I think you are looking for the datetime module.
You can get a human-readable time from a timestamp in the following manner:
from datetime import datetime
def convert(timestamp):
return datetime.fromtimestamp(timestamp).time()
How can I parse the time 004:32:55 into a datetime object? This:
datetime.strptime("004:32:55", "%H:%M:%S")
doesn't work becaush %H expects two digits. Any way to add the third digit?
Three options :
s = "004:32:55"
from datetime import datetime
datetime.strptime(s[1:], "%H:%M:%S") # from second 0 to the end
datetime.strptime(s, "0%H:%M:%S") # add 0 in formatting
from dateutil import parser # use dateutil
parser.parse(s)
There are 24 hours in a day so you can divide and get the modulus to figure out how many days and hours are in the time, then subtract the days, this needs some tweaking will get you started.
s = "04:32:55"
s = s.split(":",1)
hours, days = divmod(int(s[0]),24)
new_time = "{}:{}".format(hours,s[1])
past = datetime.now() - timedelta(days=days)
final = "{} {}".format(past.date().isoformat(),new_time)
print datetime.strptime(final,"%Y-%m-%d %H:%M:%S")
I chose a more pragmatic approach in the end and converted the time stamp to seconds:
hours = (0 if time_string.split(":")[0] == "000" else int(time_string.split(":")[0].lstrip("0")) * 3600)
mins = (0 if time_string.split(":")[1] == "00" else int(time_string.split(":")[1].lstrip("0")) * 60)
secs = (0 if time_string.split(":")[2] == "00" else int(time_string.split(":")[2].lstrip("0")))
return hours + mins + secs
Converting back to hours, minutes, and seconds is easy with datetime.timedelta(seconds=123).
EDIT:
A better solution (thanks to Ben):
hours = int(time_string.split(":")[0]) * 3600
mins = int(time_string.split(":")[1]) * 60
secs = int(time_string.split(":")[2])
return hours + mins + secs
I have timestamps that are calculated by a given interval. Ex: timestamp being 193894 and interval being 20000. The time is calculated by doing 193894/20000 = 9.6947. 9.6947 being 9 minutes and 0.6947 of a minute in seconds (0.6947 * 60) = 42 s (rounded up) thus the human readable timestamp being 9 min 42 sec.
Is there a Pythonic (assuming there is some library) way of doing this rather than doing a silly math calculation like this for every timestamp?
The reason being is because if timestamp is 1392338 (1 hour 9 min 37 sec) something that yields in the hours range, I want to be able to keep it dynamic.
I am just wondering if there was a better way to do this than the mathematical calculation way.
The linked question can help you actually format timedelta object once you have it, but there are a few tweaks you need to make to get the exact behavior you want
from __future__ import division
from datetime import timedelta
from math import ceil
def get_interval(timestamp, interval):
# Create our timedelta object
td = timedelta(minutes=timestamp/interval)
s = td.total_seconds()
# This point forward is based on http://stackoverflow.com/a/539360/2073595
hours, remainder = divmod(s, 3600)
minutes = remainder // 60
# Use round instead of divmod so that we'll round up when appropriate.
# To always round up, use math.ceil instead of round.
seconds = round(remainder - (minutes * 60))
return "%d hours %d min %d sec" % (hours, minutes, seconds)
if __name__ == "__main__:
print print_interval(1392338, 20000)
print get_interval(193894, 20000)
Output:
1 hours 9 min 37 sec
0 hours 9 min 42 sec
I need to get time in format: hour:minutes:seconds. But if I use:
time.strftime('%H:%M:%S', time.gmtime(my_time))) #my_time is float
hour have a 24-hour clock (00 to 23). And when I have for example 25 hour and 2 minutes, it writes 1:02:00, but I need 25:02:00. How can I solve it? Thank you.
Don't use time.strftime() to format elapsed time. You can only format a time of day value with that; the two types of values are related but not the same thing.
You'll need to use custom formatting instead.
If my_time is elapsed time in seconds, you can use the following function to format it to a hours:minutes:seconds format:
def format_elapsed_time(seconds):
seconds = int(seconds + 0.5) # round to nearest second
minutes, seconds = divmod(seconds, 60)
hours, minutes = divmod(minutes, 60)
return '{:02d}:{:02d}:{:02d}'.format(hours, minutes, seconds)
Demo:
>>> def format_elapsed_time(seconds):
... seconds = int(seconds + 0.5) # round to nearest second
... minutes, seconds = divmod(seconds, 60)
... hours, minutes = divmod(minutes, 60)
... return '{:02d}:{:02d}:{:02d}'.format(hours, minutes, seconds)
...
>>> format_elapsed_time(90381.33)
'25:06:21'