Saya memiliki baris perintah program dalam Python yang membutuhkan waktu untuk menyelesaikan. Saya ingin mengetahui secara pasti waktu yang dibutuhkan untuk menyelesaikan berjalan.
I've melihat waktuhal
modul, tetapi tampaknya itu's hanya untuk potongan kecil dari kode. Aku ingin waktu seluruh program.
Cara paling sederhana di Python:
import time
start_time = time.time()
main()
print("--- %s seconds ---" % (time.time() - start_time))
Ini mengasumsikan bahwa program anda membutuhkan setidaknya sepersepuluh dari kedua berjalan.
Cetakan:
--- 0.764891862869 seconds ---
Saya menempatkan ini timing.py
modul ke saya sendiri site-packages
direktori, dan hanya memasukkan impor timing
di atas saya modul:
import atexit
from time import clock
def secondsToStr(t):
return "%d:%02d:%02d.%03d" % \
reduce(lambda ll,b : divmod(ll[0],b) + ll[1:],
[(t*1000,),1000,60,60])
line = "="*40
def log(s, elapsed=None):
print line
print secondsToStr(clock()), '-', s
if elapsed:
print "Elapsed time:", elapsed
print line
print
def endlog():
end = clock()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
def now():
return secondsToStr(clock())
start = clock()
atexit.register(endlog)
log("Start Program")
Saya juga dapat panggilan waktu.log
dari dalam program saya jika ada yang signifikan tahapan dalam program aku ingin menunjukkan. Tapi hanya seperti impor timing
akan mencetak waktu awal dan akhir, dan keseluruhan waktu yang telah berlalu. (Maafkan saya jelas secondsToStr
fungsi, itu hanya format floating point jumlah detik untuk hh:mm:ss.sss bentuk.)
Catatan: Python versi 3 dari kode di atas dapat ditemukan di sini atau di sini.
Aku benar-benar seperti Paul McGuire's jawaban, tapi saya menggunakan Python 3. Jadi bagi mereka yang tertarik: here's modifikasi dari jawaban-nya yang bekerja dengan Python 3 di *nix (saya membayangkan, di bawah Windows, yang jam()
harus digunakan sebagai pengganti dari time()
):
#python3
import atexit
from time import time, strftime, localtime
from datetime import timedelta
def secondsToStr(elapsed=None):
if elapsed is None:
return strftime("%Y-%m-%d %H:%M:%S", localtime())
else:
return str(timedelta(seconds=elapsed))
def log(s, elapsed=None):
line = "="*40
print(line)
print(secondsToStr(), '-', s)
if elapsed:
print("Elapsed time:", elapsed)
print(line)
print()
def endlog():
end = time()
elapsed = end-start
log("End Program", secondsToStr(elapsed))
start = time()
atexit.register(endlog)
log("Start Program")
Jika anda menemukan ini berguna, anda harus tetap up-vote jawabannya bukan yang satu ini, karena dia melakukan sebagian besar pekerjaan ;).
import time
start_time = time.clock()
main()
print time.clock() - start_time, "seconds"
waktu.jam()
mengembalikan waktu prosesor, yang memungkinkan kita untuk menghitung hanya waktu yang digunakan oleh proses ini (pada Unix pula). Dokumentasi mengatakan "dalam hal apapun, ini adalah fungsi yang digunakan untuk pembandingan Python atau waktu algoritma"
Anda dapat menggunakan python profiler cProfile untuk mengukur CPU selain itu berapa banyak waktu yang dihabiskan di dalam fungsi masing-masing dan berapa banyak setiap kali fungsi dipanggil. Hal ini sangat berguna jika anda ingin meningkatkan kinerja anda script tanpa mengetahui di mana untuk memulai. Jawaban untuk yang lain JADI pertanyaan adalah cukup baik. It's selalu baik untuk melihat-lihat di docs juga.
Berikut ini's contoh bagaimana profil script menggunakan cProfile dari baris perintah:
$ python -m cProfile euler048.py
1007 function calls in 0.061 CPU seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.061 0.061 <string>:1(<module>)
1000 0.051 0.000 0.051 0.000 euler048.py:2(<lambda>)
1 0.005 0.005 0.061 0.061 euler048.py:2(<module>)
1 0.000 0.000 0.061 0.061 {execfile}
1 0.002 0.002 0.053 0.053 {map}
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler objects}
1 0.000 0.000 0.000 0.000 {range}
1 0.003 0.003 0.003 0.003 {sum}
Aku suka output datetime
menyediakan modul, di mana waktu delta benda-benda yang menunjukkan hari, jam, menit, dll. seperti yang diperlukan pada manusia-cara mudah dibaca.
Misalnya:
from datetime import datetime
start_time = datetime.now()
# do your work here
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
Contoh output misalnya
Duration: 0:00:08.309267
atau
Duration: 1 day, 1:51:24.269711
Update: Seperti J. F. Sebastian disebutkan, pendekatan ini mungkin mengalami beberapa kasus rumit dengan waktu setempat, sehingga's lebih aman untuk digunakan:
import time
from datetime import timedelta
start_time = time.monotonic()
end_time = time.monotonic()
print(timedelta(seconds=end_time - start_time))
Bahkan lebih baik untuk Linux: /usr/bin/time
$ /usr/bin/time -v python rhtest2.py
Command being timed: "python rhtest2.py"
User time (seconds): 4.13
System time (seconds): 0.07
Percent of CPU this job got: 91%
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:04.58
Average shared text size (kbytes): 0
Average unshared data size (kbytes): 0
Average stack size (kbytes): 0
Average total size (kbytes): 0
Maximum resident set size (kbytes): 0
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 15
Minor (reclaiming a frame) page faults: 5095
Voluntary context switches: 27
Involuntary context switches: 279
Swaps: 0
File system inputs: 0
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0
Biasanya, hanya waktu
adalah sederhana shell builtin bahwa bayangan yang lebih mampu /usr/bin/time
.
The solusi rogeriopvl bekerja dengan baik, tetapi jika anda ingin info lebih spesifik anda dapat menggunakan Python built-in profiler. Periksa halaman ini:
http://docs.python.org/library/profile.html
profiler memberitahu anda banyak informasi yang berguna seperti waktu yang dihabiskan di setiap fungsi
waktu.jam()
sudah Ditinggalkan sejak versi 3.3: perilaku dari fungsi ini tergantung pada platform: menggunakan perf_counter() atau process_time() sebaliknya, tergantung pada kebutuhan anda, untuk memiliki didefinisikan dengan perilaku.
waktu.perf_counter()
Mengembalikan nilai (dalam pecahan detik) kinerja counter, yaitu sebuah jam dengan resolusi tertinggi yang tersedia untuk mengukur pendek durasi. Ini tidak termasuk waktu yang telah berlalu selama tidur dan sistem-lebar.
waktu.process_time()
Mengembalikan nilai (dalam pecahan detik) dari jumlah sistem dan pengguna waktu CPU dari proses saat ini. Ini tidak termasuk waktu berlalu selama tidur.
start = time.process_time()
... do something
elapsed = (time.process_time() - start)
Berikut cuplikan cetakan berlalu waktu yang baik yang dapat dibaca manusia <HH:MM:SS>
format.
import time
from datetime import timedelta
start_time = time.time()
#
# Perform lots of computations.
#
elapsed_time_secs = time.time() - start_time
msg = "Execution took: %s secs (Wall clock time)" % timedelta(seconds=round(elapsed_time_secs))
print(msg)
Hanya Menggunakan waktuhal
modul. Ia bekerja dengan kedua Python 2 Dan Python 3
import timeit
start = timeit.default_timer()
#ALL THE PROGRAM STATEMETNS
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time) #It returns time in sec
Kembali dalam hitungan Detik dan anda dapat memiliki Waktu Eksekusi. Sederhana tapi anda harus menulis ini di Fungsi Utama yang dimulai eksekusi program. Jika anda ingin mendapatkan waktu Eksekusi bahkan ketika anda mendapatkan error kemudian mengambil parameter "Mulai" untuk itu dan menghitung ada seperti
def sample_function(start,**kwargs):
try:
#your statements
Except:
#Except Statements
stop = timeit.default_timer()
execution_time = stop - start
print("Program Executed in "+execution_time)
I've melihat waktuhal modul, tetapi tampaknya itu's hanya untuk potongan kecil dari kode. Aku ingin waktu seluruh program.
$ python -mtimeit -n1 -r1 -t -s "from your_module import main" "main()"
Itu berjalan your_module.main()
fungsi satu kali dan mencetak waktu yang telah berlalu menggunakan waktu.waktu()
fungsi sebagai timer.
Untuk meniru /usr/bin/time
di Python melihat Python subproses dengan /usr/bin/time: bagaimana untuk menangkap waktu info tapi mengabaikan semua output yang lain?.
Untuk mengukur waktu CPU (misalnya, don't memiliki waktu selama waktu.tidur()
) untuk masing-masing fungsi, anda bisa menggunakan profil
modul (cProfile
pada Python 2):
$ python3 -mprofile your_module.py
Anda bisa melewati -p
untuk waktuhal
perintah di atas jika anda ingin menggunakan timer sebagai profil
modul menggunakan.
Gunakan line_profiler.
line_profiler akan profil waktu individu baris kode yang diperlukan untuk mengeksekusi. Profiler diimplementasikan dalam C melalui Acpi dalam rangka untuk mengurangi overhead dari profiling.
from line_profiler import LineProfiler
import random
def do_stuff(numbers):
s = sum(numbers)
l = [numbers[i]/43 for i in range(len(numbers))]
m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
numbers = [random.randint(1,100) for i in range(1000)]
lp = LineProfiler()
lp_wrapper = lp(do_stuff)
lp_wrapper(numbers)
lp.print_stats()
Hasilnya akan menjadi:
Timer unit: 1e-06 s
Total time: 0.000649 s
File: <ipython-input-2-2e060b054fea>
Function: do_stuff at line 4
Line # Hits Time Per Hit % Time Line Contents
==============================================================
4 def do_stuff(numbers):
5 1 10 10.0 1.5 s = sum(numbers)
6 1 186 186.0 28.7 l = [numbers[i]/43 for i in range(len(numbers))]
7 1 453 453.0 69.8 m = ['hello'+str(numbers[i]) for i in range(len(numbers))]
Aku seperti Paul McGuire's jawaban juga dan datang dengan konteks manager bentuk yang lebih cocok dengan kebutuhan saya.
import datetime as dt
import timeit
class TimingManager(object):
"""Context Manager used with the statement 'with' to time some execution.
Example:
with TimingManager() as t:
# Code to time
"""
clock = timeit.default_timer
def __enter__(self):
"""
"""
self.start = self.clock()
self.log('\n=> Start Timing: {}')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""
"""
self.endlog()
return False
def log(self, s, elapsed=None):
"""Log current time and elapsed time if present.
:param s: Text to display, use '{}' to format the text with
the current time.
:param elapsed: Elapsed time to display. Dafault: None, no display.
"""
print s.format(self._secondsToStr(self.clock()))
if(elapsed is not None):
print 'Elapsed time: {}\n'.format(elapsed)
def endlog(self):
"""Log time for the end of execution with elapsed time.
"""
self.log('=> End Timing: {}', self.now())
def now(self):
"""Return current elapsed time as hh:mm:ss string.
:return: String.
"""
return str(dt.timedelta(seconds = self.clock() - self.start))
def _secondsToStr(self, sec):
"""Convert timestamp to h:mm:ss string.
:param sec: Timestamp.
"""
return str(dt.datetime.fromtimestamp(sec))
Saya menggunakan fungsi yang sangat sederhana untuk waktu bagian dari eksekusi kode:
import time
def timing():
start_time = time.time()
return lambda x: print("[{:.2f}s] {}".format(time.time() - start_time, x))
Dan untuk menggunakannya, sebut saja sebelum kode untuk mengukur untuk mengambil fungsi waktu, maka panggil fungsi setelah kode dengan komentar, dan waktu yang akan muncul di depan komentar, misalnya:
t = timing()
train = pd.read_csv('train.csv',
dtype={
'id': str,
'vendor_id': str,
'pickup_datetime': str,
'dropoff_datetime': str,
'passenger_count': int,
'pickup_longitude': np.float64,
'pickup_latitude': np.float64,
'dropoff_longitude': np.float64,
'dropoff_latitude': np.float64,
'store_and_fwd_flag': str,
'trip_duration': int,
},
parse_dates = ['pickup_datetime', 'dropoff_datetime'],
)
t("Loaded {} rows data from 'train'".format(len(train)))
Maka output akan terlihat seperti ini:
[9.35s] Loaded 1458644 rows data from 'train'
Aku merasa sedikit elegan dengan cara ini.
Di dalam sel, anda dapat menggunakan Jupyter's %%time
sihir perintah untuk mengukur waktu eksekusi:
%%time
[ x**2 for x in range(10000)]
Output Waktu CPU: pengguna 4.54 ms, sys: 0 ns, total: 4.54 ms Dinding waktu: 4.12 ms
Ini hanya akan menangkap waktu eksekusi dari suatu sel tertentu. Jika anda'd seperti untuk menangkap waktu pelaksanaan dari seluruh notebook (yaitu program), anda dapat membuat notebook baru di direktori yang sama dan dalam notebook baru mengeksekusi semua sel-sel:
Misalkan notebook di atas disebut example_notebook.ipynb
. Di notebook baru dalam direktori yang sama:
# Convert your notebook to a .py script:
!jupyter nbconvert --to script example_notebook.ipynb
# Run the example_notebook with -t flag for time
%run -t example_notebook
Output IPython CPU timing (perkiraan): Pengguna : 0.00 s. Sistem : 0.00 s. Dinding waktu: 0.00 s.