# `time` — Zaman erişimi ve dönüşümleri

Bu modül zamanla alakalı çeşitli fonksiyonlar sağlar. Alakalı fonksiyonellik için, `datetime` ve `calendar` modüllerine göz atın.

Bu modül her zaman kullanılabilir olmasına rağmen, bütün fonksiyonlar bütün platformlarda kullanılamaz. Bu modülde tanımlanmış fonksiyonlar çoğu aynı isimli C platform kütüphanesinin fonksiyonlarını çağırır. Fonksiyonların anlamları platformlar arasında değiştiğinden bazen platform dokümantasyonuna başvurmak yardımcı olabilir.

Sırada biraz terminoloji ve kural açıklamaları var.

- epoch zamanın başladığı noktadır, `time.gmtime(0)`’nun dönüş değeridir. Bütün platformlarda 1 Ocak, 1970, 00:00:00 (UTC) şeklindedir.

- seconds since the epoch terimi başlangıçtan beri geçen toplam saniyeyi ifade eder, tipik olarak leap seconds hariç. Artık saniyeler POSIX-uyumlu tüm platformlardan çıkarılmıştır.

- Bu modüldeki fonksiyonlar epoch ‘den önce olan veya çok uzak gelecekte olan tarihleri ve zamanları çalıştıramayabilirler. Sona erme noktası 32-bit sistemler için C kütüphanesi tarafından belirlenmiştir, tipik olarak 2038’dir.

- `strptime()` fonksiyonu `%y` biçimi verildiğinde 2 haneli yılları ayrıştırabilir. 2 haneli yıllar ayrıştırıldığında, POSIX ve ISO C standartlarına göre dönüştürülürler; 69–99 değerleri 1969–1999 değerlerine, 0–68 değerleri 2000–2068 değerlerine eşlenirler.

- UTC, Koordineli Evrensel Zaman (eski haliyle Greenwich Ortalama Zamanı, ya da GMT) anlamına gelir. UTC kısaltması bir hata değil, İngilizce ve Fransızca arasında bir uzlaşmadır.

- DST, Yaz Saati Uygulaması, yılın bir kısmında saat diliminin (genellikle) bir saat ayarlanmasına denir. DST kuralları büyülüdür (yerel yasalar tarafından belirlenir) ve yıldan yıla değişebilir. C kütüphanesi yerel kuralları (genellikle esneklik için bir sistem dosyasından okunur) içeren bir tabloya sahiptir ve Gerçek Bilgeliğin tek kaynağıdır.

- Çeşitli gerçek-zamanlı fonksiyonların hassasiyeti birimlerin değerlerinin veya argümanlarının ifade edildiği önerilerden daha az olabilir. Örneği çoğu Unix sistemlerinde, saat yalnızca 50 veya 100 defa “çalışır”.

- On the other hand, the precision of `time()` and `sleep()` is better than their Unix equivalents: times are expressed as floating point numbers, `time()` returns the most accurate time available (using Unix `gettimeofday()` where available), and `sleep()` will accept a time with a nonzero fraction (Unix `select()` is used to implement this, where available).

- `gmtime()`, `localtime()`, ve `strptime()`, tarafından döndürülen ve `asctime()`, `mktime()` ve `strftime()`, tarafından kabul edilen zaman değeri 9 tam sayılık bir dizidir. `gmtime()`, `localtime()`, ve `strptime()` tarafından döndürülen değerler ayrıca ayrı alanlar için ayrı öznitelik isimleri sunar.

  Bu nesnelerin açıklamalarını görmek için `struct_time`’a göz at.

  3.3 sürümünde değişti: The `struct_time` type was extended to provide the `tm_gmtoff` and `tm_zone` attributes when platform supports corresponding `struct tm` members.

  3.6 sürümünde değişti: The `struct_time` attributes `tm_gmtoff` and `tm_zone` are now available on all platforms.

- Zaman temsilleri arasında dönüşüm yapmak için belirtilen fonksiyonları kullanın:

  Den | Karşı | Kullan
  --- | --- | ---
  zamanın başlangıcından beri geçen saniye | UTC içinde `struct_time` | `gmtime()`
  zamanın başlangıcından beri geçen saniye | yerel zaman içinde `struct_time` | `localtime()`
  UTC içinde `struct_time` | zamanın başlangıcından beri geçen saniye | `calendar.timegm()`
  yerel zaman içinde `struct_time` | zamanın başlangıcından beri geçen saniye | `mktime()`

## Fonksiyonlar

time.asctime([t])

  `gmtime()` veya `localtime()` tarafından döndürülen bir zamanı temsil eden bir demet veya `struct_time` öğesini şu forma sahip bir dizeye dönüştürün: `'Sun Jun 20 23:21:05 1993'`. Gün alanı iki karakter uzunluğundadır ve gün tek harfliyse boşluk karakteriyle doldurulur, örnek: `'Wed Jun 9 04:26:40 1993'`.

  Eğer t sağlanmamışsa, `localtime()` tarafından döndürülen şimdiki zaman kullanılır. Yerel bilgi `asctime()` tarafından kullanılmaz.

  Not

  Aynı isimli C fonksiyonunun aksine, `asctime()` sona yeni satır eklemez.

time.pthread_getcpuclockid(thread_id)

  Belirtilen thread_id için iş parçacığına özgü CPU-zaman saatinin clk_id değerini döndürür.

  thread_id için uygun bir değer elde etmek için `threading.get_ident()` veya `threading.Thread` nesnelerinin `ident` özniteliğini kullanın.

  Uyarı

  Geçersiz veya süresi geçmiş bir thread_id girişi yapmak, bölümleme hatası gibi, tanımlanmamış bir davranış ortaya koyabilir.

  Availability: Unix

  Daha fazla bilgi için pthread_getcpuclockid(3) el kitabına göz atın.

  3.7 sürümünde geldi.

time.clock_getres(clk_id)

  Belirtilen clk_id saatinin netliğini (kesinliğini) döndür. clk_id’e uygun değerlerin bir listesi için Saat Kimliği Sabitleri’a bakınız.

  Availability: Unix.

  3.3 sürümünde geldi.

time.clock_gettime(clk_id) → float

  Belirtilen clk_id saatinin zamanını döndür. clk_id’e uygun değerlerin bir listesi için Saat Kimliği Sabitleri’a bakınız.

  `float` türü sebebiyle oluşan kesinlik kaybından kaçınmak için `clock_gettime_ns()` kullanın.

  Availability: Unix.

  3.3 sürümünde geldi.

time.clock_gettime_ns(clk_id) → int

  `clock_gettime()`’a benzer şekilde ama zamanı nanosaniyeler şeklinde döndürür.

  Availability: Unix.

  3.7 sürümünde geldi.

time.clock_settime(clk_id, time: float)

  Belirtilen clk_id saatinin zamanını ayarla. Şu anda, clk_id için kabul edilen tek değer `CLOCK_REALTIME`’dır.

  `float` türü sebebiyle oluşan kesinlik kaybından kaçınmak için `clock_settime_ns()` kullanın.

  Availability: Unix.

  3.3 sürümünde geldi.

time.clock_settime_ns(clk_id, time: int)

  `clock_settime()`’a benzer şekilde ama zamanı nanosaniyeler ile ayarlar.

  Availability: Unix.

  3.7 sürümünde geldi.

time.ctime([secs])

  epoch ‘dan bu yana saniye cinsinden ifade edilen bir süreyi bir biçim dizisine dönüştürün: yerel zamanı temsil eden `'Sun Jun 20 23:21:05 1993'`. Gün alanı iki karakter uzunluğundadır ve gün tek basamaklıysa boşluk bırakılır, örneğin: `'Wed Jun 9 04:26:40 1993'`.

  secs veya `None` sağlanmamışsa, `time()` tarafından döndürülen mevcut zaman kullanılır. `ctime(secs)` `asctime(localtime(secs))`’e karşılıktır. Yerel ayar bilgisi `ctime()` tarafından kullanılmaz.

time.get_clock_info(name)

  Belirtilen saat için namespace nesnesi şeklinde bilgi edinin. Desteklenen saat isimleri ve onların değerlerini okumaya ilişkin fonksiyonlar şunlardır:

  - `'monotonic'`: `time.monotonic()`

  - `'perf_counter'`: `time.perf_counter()`

  - `'process_time'`: `time.process_time()`

  - `'thread_time'`: `time.thread_time()`

  - `'time'`: `time.time()`

  Sonuç şu özniteliklere sahiptir:

  - Saat otomatik bir şekilde (örneğin bir NTP daemon tarafından) veya sistem yöneticisi tarafından değiştirilebiliyorsa adjustable: `True`, tersi için `False`

  - implementation: Saat değerini elde etmek için kullanılan temel C fonksiyonunun ismidir. Muhtemel değerler için Saat Kimliği Sabitleri’a bakınız.

  - monotonic: Saat geriye doğru gidemiyorsa `True`, aksi halde `False`

  - resolution: Saatin saniyeler halindeki netliği (`float`)

  3.3 sürümünde geldi.

time.gmtime([secs])

  epoch ‘dan bu yana saniye olarak ifade edilen bir zamanı, dst bayrağının her zaman sıfır olduğu UTC’de bir `struct_time`’a dönüştürün. secs sağlanmazsa veya `None`, `time()` tarafından döndürülen geçerli zaman kullanılır. Saniyenin kesirleri dikkate alınmaz. `struct_time` nesnesinin açıklaması için yukarıya bakın. Bu fonksiyonun tersi için `calendar.timegm()` konusuna bakın.

time.localtime([secs])

  `gmtime()` gibi ama yerel zamana dönüştürür. Eğer secs sağlanmazsa veya `None` ise, `time()` tarafından döndürülen şimdiki zaman kullanılır. Belirli bir süre için DST uygulandığında dst bayrağı `1` olarak ayarlanır.

  Eğer zaman damgası C `localtime()` veya `gmtime()` fonksiyonları tarafından sağlanan değer aralıkları içerisinde değilse `localtime()` `OverflowError` yükseltebilir, ve `localtime()` üzerinde `OSError` veya `gmtime()` hatasını. Bunun 1970 ile 2038 arasındaki yıllarla sınırlı olması yaygın bir durumdur.

time.mktime(t)

  Bu, `localtime()`’ın ters fonksiyonudur. Argümanı `struct_time` veya tam 9-demet (dst bayrağı gerekli olduğundan; bilinmiyorsa dst bayrağı olarak `-1` kullanın), zamanı local zamanda ifade eder, UTC değil. `time()` ile uyumluluk için bir kayan noktalı sayı döndürür. Giriş değeri geçerli bir zaman olarak gösterilemiyorsa, `OverflowError` veya `ValueError` yükseltilir (geçersiz değerin Python veya temel C kitaplıkları tarafından yakalanıp yakalanmadığına bağlıdır). Bir zaman oluşturabileceği en erken tarih, platforma bağlıdır.

time.monotonic() → float

  Monoton bir saatin değerini (kesirli saniye cinsinden) döndürür, yani bir geri gidemeyen bir saat. Saat sistem saat güncellemelerinden etkilenmez. Döndürülen değerin referans noktası tanımlanmamıştır, böylece sadece iki aramanın sonuçları arasındaki fark geçerlidir.

  `float` türünün sebep olduğu kesinlik kaybından kaçınmak için `monotonic_ns()` kullanın.

  3.3 sürümünde geldi.

  3.5 sürümünde değişti: Fonksiyon artık her zaman mevcut ve her zaman sistem çapında.

  3.10 sürümünde değişti: macOS için, fonksiyon artık sistem çapında.

time.monotonic_ns() → int

  `monotonic()`’e benzer şekilde, ama zamanı nanosaniyeler şeklinde döndürür.

  3.7 sürümünde geldi.

time.perf_counter() → float

  Bir performans sayacının değerini (kesirli saniye cinsinden) döndürür, örnek olarak kısa bir süreyi ölçmek için mümkün olan en yüksek kesinliğe sahip bir saat. Uyku sırasında geçen süreyi içerir ve sistem çapındadır. Döndürülen değerin referans noktası tanımsızdır, yani sadece iki çağrının sonuçları arasındaki fark geçerlidir.

  `float` türü sebebiyle oluşan kesinlik kaybından kaçınmak için `perf_counter_ns()` kullanın.

  3.3 sürümünde geldi.

  3.10 sürümünde değişti: Windows için, fonksiyon artık sistem çapında.

time.perf_counter_ns() → int

  `perf_counter()`’a benzer şekilde, ama zamanı nanosaniyeler şeklinde döndürür.

  3.7 sürümünde geldi.

time.process_time() → float

  Geçerli işlemin sistem ve kullanıcı CPU zamanının toplamının değerini (kesirli saniye cinsinden) döndürür. Uykuda geçen süreyi dahil etmez. Tanım gereği işlem çapındadır. Döndürülen değerin referans noktası tanımsızdır, yani sadece iki çağrının sonuçları arasındaki fark geçerlidir.

  `float` türü sebebiyle oluşan kesinlik kaybından kaçınmak için `process_time_ns()` kullanın.

  3.3 sürümünde geldi.

time.process_time_ns() → int

  `process_time()`’a benzer şekilde, ama zamanı nanosaniyeler şeklinde döndürür.

  3.7 sürümünde geldi.

time.sleep(secs)

  Çağıran iş parçacığının yürütülmesini verilen saniye sayısı kadar askıya alın. Argüman, daha kesin bir uyku zamanını belirtmek için kayan noktalı bir sayı olabilir.

  Eğer uyku bir sinyal tarafından kesintiye uğrarsa ve sinyal işleyicisi tarafından herhangi bir istisna yükseltilmezse, uyku yeniden hesaplanmış bir zaman aşımıyla tekrar başlar.

  Askıya alma süresi isteğe bağlı bir değer ile istenilenden daha uzun tutulabilir, sebebiyse diğer aktivitelerin sistem içerisindeki planlanmasıdır.

  Windows’ta secs sıfırsa, iş parçacığı zaman diliminin geri kalanını çalışmaya hazır olan başka bir iş parçacığına bırakır. Çalışmaya hazır başka iş parçacığı yoksa fonksiyon hemen geri döner ve iş parçacığı çalışmaya devam eder. Windows 8.1 ve daha yeni sürümlerde uygulama, 100 nanosaniyenin kesinliğini sağlayan bir high-resolution timer kullanır. secs sıfırsa, `Sleep(0)` kullanılır.

  Unix uyarlaması:

  - Kullanılabilirse `clock_nanosleep()` kullanın (netlik: 1 nanosaniye);

  - Ya da kullanılabiliyorsa `nanosleep()` kullanın (netlik: 1 nanosaniye);

  - Ya da `select()` kullanın (netlik: 1 mikrosaniye).

  3.5 sürümünde değişti: Fonksiyon artık bir sinyal tarafından kesilirse bile secs süresince uyur, sinyal işleyicisi tarafından bir istisna yükseltilmesi durumu hariç (açıklaması için PEP 475’e göz atın).

  3.11 sürümünde değişti: Unix’de, `clock_nanosleep()` ve `nanosleep()` fonksiyonları artık kullanılabiliyor. Windows’da, artık beklenebilir bir zamanlayıcı kullanılıyor.

time.strftime(format[, t])

  `gmtime()` veya `localtime()` tarafından döndürülen bir zamanı temsil eden bir demet veya `struct_time`’ı format bağımsız değişkeni tarafından belirtilen bir dizeye dönüştürün. t sağlanmazsa, `localtime()` tarafından döndürülen geçerli saat kullanılır. format bir dize olmalıdır. `ValueError`, t içindeki herhangi bir alan izin verilen aralığın dışındaysa yükseltilir.

  0 zaman demeti içerisindeki herhangi bir pozisyon için geçerli bir argümandır; normalde geçersiz ise, değer doğru bir değere zorlanır.

  Aşağıdaki direktifler format dizesine gömülebilir. İsteğe bağlı alan genişliği ve kesinlik belirtimi olmadan gösterilirler ve `strftime()` sonucunda belirtilen karakterlerle değiştirilirler:

  Yönerge | Anlamı | Notlar
  --- | --- | ---
  `%a` | Yerel ayarın kısaltılmış hafta içi ismi. |
  `%A` | Yerel ayarın tam hafta içi ismi. |
  `%b` | Yerel ayarın kısaltılmış ay ismi. |
  `%B` | Yerel ayarın tam ay ismi. |
  `%c` | Yerel ayarın uygun tarih ve zaman gösterimi. |
  `%d` | Onluk sayı şeklinde ayın günü [01,31]. |
  `%f` | Microseconds as a decimal number [000000,999999]. | (1)
  `%H` | Onluk sayı şeklinde saat (24-saatlik sistem) [00,23]. |
  `%I` | Onluk sayı şeklinde saat (12-saatlik sistem) [01,12]. |
  `%j` | Onluk sayı şeklinde yılın günü [001,366]. |
  `%m` | Onluk sayı şeklinde ay [01,12]. |
  `%M` | Onluk sayı şeklinde dakika [00,59]. |
  `%p` | Yerel ayarın AM veya PM’e göre karşılığı. | (2)
  `%S` | Onluk sayı şeklinde saniye [00,61]. | (3)
  `%U` | Onluk sayı şeklinde yılın (Pazar haftanın ilk günü olacak şekilde) hafta numarası [00,53]. Yeni bir yılın ilk Pazar gününden önceki tüm günleri 0. hafta olarak kabul edilir. | (4)
  `%w` | Onluk sayı şeklinde hafta içi [0(Sunday),6]. |
  `%W` | Onluk sayı şeklinde yılın (Pazartesi haftanın ilk günü olacak şekilde) hafta numarası [00,53]. Yeni bir yılın ilk Pazartesi gününden önceki tüm günleri 0. hafta olarak kabul edilir. | (4)
  `%x` | Yerel ayarın uygun tarih gösterimi. |
  `%X` | Yerel ayarın uygun zaman gösterimi. |
  `%y` | Onluk sayı şeklinde yüzyıl olmadan yıl [00,99]. |
  `%Y` | Onluk sayı şeklinde yüzyıl ile birlikte yıl. |
  `%z` | +HHMM veya -HHMM biçimindeki UTC/GMT’den pozitif veya negatif bir zaman farkını gösteren saat dilimi farkı, burada H ondalık saat hanelerini ve M ondalık dakika hanelerini temsil eder [-23:59, +23:59]. [1] |
  `%Z` | Yerel zaman ismi (yerel zaman bulunmuyorsa karakter girmeyin). Kullanımdan kaldırıldı. [1] |
  `%%` | Gerçek bir `'%'` karakteri. |

  Notlar:

  1. The `%f` format directive only applies to `strptime()`, not to `strftime()`. However, see also `datetime.datetime.strptime()` and `datetime.datetime.strftime()` where the `%f` format directive applies to microseconds.

  2. `strptime()` işleviyle kullanıldığında, `%p` yönergesi yalnızca, saati ayrıştırmak için `%I` yönergesi kullanılıyorsa, çıkış saati alanını etkiler.

  3. Aralık gerçekten de `0`’dan `61`’e kadardır; `60` değeri leap seconds ‘u temsil eden zaman damgalarında geçerlidir ve `61` değeriyse tarihsel nedenlerden ötürü desteklenmektedir.

  4. `%U` ve `%W` ifadeleri, `strptime()` fonksiyonu ile kullanıldığında, yalnızca haftanın günü ve yıl belirtilmişse hesaplamalarda kullanılır.

  İşte bir örnek, RFC 2822 İnternet e-posta standardında belirtilenle uyumlu tarih biçimi. [1]

      >>> from time import gmtime, strftime
      >>> strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
      'Thu, 28 Jun 2001 14:17:15 +0000'

  Belirli platformlarda ek yönergeler desteklenebilir, ancak yalnızca burada listelenenlerin ANSI C tarafından standartlaştırılmış bir anlamı vardır. Platformunuzda desteklenen tüm biçim kodlarını görmek için strftime(3) belgelerine bakın.

  Bazı platformlarda, isteğe bağlı bir alan genişliği ve kesinlik belirtimi, bir yönergenin ilk `'%'` ifadesini aşağıdaki sırayla hemen takip edebilir; bu da taşınabilir değil. Alan genişliği, 3 olduğu `%j` dışında normalde 2’dir.

time.strptime(string[, format])

  Bir biçime göre bir zamanı temsil eden bir dizeyi ayrıştırın. Dönüş değeri, `gmtime()` veya `localtime()` tarafından döndürülen bir `struct_time` şeklindedir.

  format parametresi, `strftime()` tarafından kullanılanlarla aynı yönergeleri kullanır; varsayılan olarak `ctime()` tarafından döndürülen biçimlendirmeyle eşleşen `"%a %b %d %H:%M:%S %Y"` şeklindedir. string format’a göre ayrıştırılamazsa veya ayrıştırma sonrasında fazla veriye sahipse `ValueError` yükseltilir. Daha doğru değerler çıkarılamadığında eksik verileri doldurmak için kullanılan varsayılan değerler `(1900, 1, 1, 0, 0, 0, 0, 1, -1)` şeklindedir. Hem string hem de format dize olmalıdır.

  Örnek olarak:

      >>> import time
      >>> time.strptime("30 Nov 00", "%d %b %y")
      time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0,
                       tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

  `%Z` yönergesi için destek, `tzname` içinde bulunan değerlere ve `daylight` ifadesinin doğru olup olmadığına bağlıdır. Bu nedenle, her zaman bilinen (ve gün ışığından yararlanma saat dilimleri olarak kabul edilen) UTC ve GMT’yi tanımak dışında platforma özgüdür.

  Yalnızca belgelerde belirtilen yönergeler desteklenir. `strftime()` platform başına uygulandığından, bazen listelenenlerden daha fazla yönerge sunabilir. Ancak `strptime()` herhangi bir platformdan bağımsızdır ve bu nedenle desteklendiği belgelenmeyen mevcut tüm yönergeleri desteklemeyebilir.

class time.struct_time

  `gmtime()`, `localtime()` ve `strptime()` tarafından döndürülen zaman değeri dizisinin türü. named tuple arayüzüne sahip bir nesnedir: değerlere dizin ve öznitelik adıyla erişilebilir. Aşağıdaki değerler mevcuttur:

  Dizin | Öznitelik | Değerler
  0 | tm_year | (örnek olarak, 1993)
  1 | tm_mon | [1, 12] aralığı
  2 | tm_day | [1, 31] aralığı
  3 | tm_hour | [0, 23] aralığı
  4 | tm_min | [0, 59] aralığa
  5 | tm_sec | range [0, 61]; see Note (2) in `strftime()`
  6 | tm_wday | range [0, 6]; Monday is 0
  7 | tm_yday | [1, 366] aralığı
  8 | tm_isdst | 0, 1 veya -1; aşağıya bakınız
  N/A | tm_zone | saat diliminin adının kısaltması
  N/A | tm_gmtoff | UTC’nin doğusundaki saniye farkı

  C yapısından farklı olarak, ay değerinin menzili [1, 12] arasındadır, [0, 11] değil.

  `mktime()` çağrılarında, `tm_isdst` yaz saati uygulaması etkinken 1, etkin değilken 0 olarak ayarlanabilir. -1 değeri bunun bilinmediğini gösterir ve genellikle doğru durumun doldurulmasıyla sonuçlanır.

  `struct_time` bekleyen bir fonksiyona yanlış uzunluğa sahip bir demet iletildiğinde, veya yanlış türde elemanlara sahip olmak, bir `TypeError` yükseltir.

time.time() → float

  epoch ‘dan bu yana geçen süreyi kayan noktalı bir sayı olarak saniye cinsinden döndürür. leap seconds ‘ın ele alınması platforma bağlıdır. Windows’ta ve çoğu Unix sisteminde, artık saniyeler, epoch’dan bu yana saniye cinsinden süreye dahil edilmez. Bu genellikle Unix time olarak anılır.

  Zamanın her zaman bir kayan noktalı sayı olarak döndürülmesine rağmen, tüm sistemlerin zamanı 1 saniyeden daha iyi kesinlikte sağlamadığını unutmayın. Bu fonksiyon normalde azalmayan değerler döndürürken, sistem saati iki çağrı arasında geri ayarlanmışsa önceki çağrıdan daha düşük bir değer döndürebilir.

  `time()` tarafından döndürülen sayı UTC’de `gmtime()` fonksiyonuna geçirerek veya yerel saatte `localtime()` fonksiyonuna geçirerek daha yaygın bir zaman biçimine döndürülebilir (yıl, ay, gün, saat vb. gibi). Her iki durumda da, takvim tarihinin bileşenlerine nitelikler olarak erişilebilen bir `struct_time` nesnesi döndürülür.

  `float` türünden kaynaklanan kesinlik kaybından kaçınmak için `time_ns()` kullanınız.

time.time_ns() → int

  `time()`’ye benzer, ancak zamanı, epoch ‘den bu yana geçen nanosaniyelerin tamsayısı olarak döndürür.

  3.7 sürümünde geldi.

time.thread_time() → float

  Geçerli iş parçacığının sistem ve kullanıcı CPU zamanının toplamının değerini (kesirli saniye cinsinden) döndürür. Uykuda geçen süreyi dahil etmez. Tanım gereği iş parçacığı çapındadır. Döndürülen değerin referans noktası tanımsızdır, böylece sadece aynı iş parçacığındaki iki çağrının sonuçları arasındaki fark geçerlidir.

  `float` türünün neden olduğu kesinlik kaybını önlemek için `thread_time_ns()` kullanın.

  Availability: Linux, Unix, Windows.

  Unix sistemler `CLOCK_THREAD_CPUTIME_ID` destekliyor.

  3.7 sürümünde geldi.

time.thread_time_ns() → int

  `thread_time()` ile benzer şekilde ama zamanı nanosaniyeler şeklinde döndürür.

  3.7 sürümünde geldi.

time.tzset()

  Kütüphane rutinleri tarafından kullanılan zaman dönüştürme kurallarını sıfırlayın. `TZ` ortam değişkeni bunun nasıl yapıldığını belirtir. Ayrıca tzname ( `TZ` ortam değişkeninden), `timezone` (UTC’nin batısındaki DST olmayan saniyeler), `altzone` (UTC’nin batısındaki DST saniyeleri) değişkenlerini de ayarlayacaktır. ) ve `daylight` (bu saat diliminde herhangi bir yaz saati uygulaması kuralı yoksa 0’a veya gün ışığından yararlanma saatinin uygulandığı geçmiş, şimdi veya gelecek bir zaman varsa sıfırdan farklı).

  Availability: Unix.

  Not

  Çoğu durumda, `TZ` ortam değişkenini değiştirmek, `localtime()` gibi işlevlerin çıktısını `tzset()` çağırmadan etkileyebilirse de, bu davranışa güvenilmemelidir.

  `TZ` çevre değişkeni boşluk karakteri içermemelidir.

  `TZ` çevre değişkeninin standart biçimi (boşluk karakteri açıklık için eklenmiştir):

      std offset [dst [offset [,start[/time], end[/time]]]]

  Bileşenlerin olduğu yerde:

  `std` ve `dst`

    Üç veya daha fazla harfler ve sayılar saat dilimi kısaltmalarını veriyor. Bunlar time.tzname içine yayılacaktır

  `offset`

    Göreli konum şu biçimdedir: `± hh[:mm[:ss]]`. Bu, UTC’ye varmak için yerel saate eklenen değeri gösterir. Başında ‘-’ varsa, saat dilimi Başlangıç Meridyeni’nin doğusundadır; aksi halde batıdır. dst’yi takip eden herhangi bir sapma yoksa, yaz saatinin standart saatten bir saat ileri olduğu varsayılır.

  `start[/time], end[/time]`

    DST’ye ne zaman geçileceğini ve DST’den geri dönüleceğini gösterir. Başlangıç ve bitiş tarihlerinin biçimi aşağıdakilerden biridir:

    `Jn`

      Jülyen günü n (1 <= n <= 365). Artık günler sayılmaz, yani bütün yıllarda 28 Şubat 59. gün ve 1 Mart 60. gündür.

    `n`

      Sıfır tabanlı Jülyen günü (0 <= n <= 365). Artık günler dahil edilmiştir, ve 29 Şubat’tan bahsetmek mümkündür.

    `Mm.n.d`

      Yılın m ayının n haftasının d’inci günü (0 <= d <= 6) (1 <= n <= 5, 1 <= m <= 12, burada 5. hafta “the last d day in month m” anlamına gelir ve dördüncü veya beşinci haftada olabilir).

    `time`, `offset` ile (‘-’ or ‘+’) ön işaretlerine izin verilmemesi haricinde aynı biçime sahiptir. Zaman verilmemişse, varsayılan olarak 02:00:00’dır.

      >>> os.environ['TZ'] = 'EST+05EDT,M4.1.0,M10.5.0'
      >>> time.tzset()
      >>> time.strftime('%X %x %Z')
      '02:07:36 05/08/03 EDT'
      >>> os.environ['TZ'] = 'AEST-10AEDT-11,M10.5.0,M3.5.0'
      >>> time.tzset()
      >>> time.strftime('%X %x %Z')
      '16:08:12 05/08/03 AEST'

  Bir çok Unix sisteminde (*BSD, Linux, Solaris, ve Darwin dahil), saat dilimi kurallarını belirlemek için sistemin zoneinfo (tzfile(5)) veritabanını kullanmak daha uygundur. Bunu yapmak için, `TZ` çevre değişkenini gerekli saat dilimi veri dosyasının konumuna ayarlayınız, sistemlerin ‘zoneinfo’ saat dilimi veritabanının köküne göre, genellikle `/usr/share/zoneinfo` konumunda bulunur. Örnek olarak, `'US/Eastern'`, `'Australia/Melbourne'`, `'Egypt'` veya `'Europe/Amsterdam'`.

      >>> os.environ['TZ'] = 'US/Eastern'
      >>> time.tzset()
      >>> time.tzname
      ('EST', 'EDT')
      >>> os.environ['TZ'] = 'Egypt'
      >>> time.tzset()
      >>> time.tzname
      ('EET', 'EEST')

## Saat Kimliği Sabitleri

Şu sabitler `clock_getres()` ve `clock_gettime()` için parametre olarak kullanılırlar.

time.CLOCK_BOOTTIME

  `CLOCK_MONOTONIC` ile aynı şekilde, ancak o sistemin askıya alındığı herhangi bir zamanı da içerir.

  Bu, uygulamaların `CLOCK_REALTIME` komplikasyonları ile uğraşmak zorunda kalmadan, zaman `settimeofday()` veya benzeri kullanılarak değiştirildiğinde süreksizliklere sahip olabilecek, askıya alma farkında monoton bir saat elde etmelerini sağlar.

  Availability: Linux >= 2.6.39.

  3.7 sürümünde geldi.

time.CLOCK_HIGHRES

  Solaris OS, en uygun donanım kaynağını kullanmaya çalışan ve nanosaniyeye yakın kesinlik sağlayabilen bir `CLOCK_HIGHRES` zamanlayıcıya sahiptir. `CLOCK_HIGHRES` ayarlanamaz, yüksek kesinlikli saattir.

  Availability: Solaris.

  3.3 sürümünde geldi.

time.CLOCK_MONOTONIC

  Belirsiz başlangıç noktasından beri ayarlanamayan ve monoton zamanı temsil eden saat.

  Availability: Unix.

  3.3 sürümünde geldi.

time.CLOCK_MONOTONIC_RAW

  `CLOCK_MONOTONIC` ile benzer, ama NTP ayarlamalarına tabii olmayan donanım bazlı ham zamana erişim sağlar.

  Availability: Linux >= 2.6.28, macOS >= 10.12.

  3.3 sürümünde geldi.

time.CLOCK_PROCESS_CPUTIME_ID

  CPU’dan yüksek kesinlikli işlem başına zamanlayıcısı.

  Availability: Unix.

  3.3 sürümünde geldi.

time.CLOCK_PROF

  CPU’dan yüksek kesinlikli işlem başına zamanlayıcısı.

  Availability: FreeBSD, NetBSD >= 7, OpenBSD.

  3.7 sürümünde geldi.

time.CLOCK_TAI

  International Atomic Time

  Bunun doğru cevabı verebilmesi için sistemin güncel bir artık saniye tablosuna sahip olması gerekir. PTP veya NTP yazılımı artık saniye tablosunu sürdürebilir.

  Availability: Linux.

  3.9 sürümünde geldi.

time.CLOCK_THREAD_CPUTIME_ID

  İş parçacığına özgü CPU zamanlayıcı saati.

  Availability: Unix.

  3.3 sürümünde geldi.

time.CLOCK_UPTIME

  Mutlak değeri sistemin çalıştığı ve askıya alınmadığı süre olan süre, hem mutlak hem de aralıklı olarak doğru çalışma süresi ölçümü sağlar.

  Availability: FreeBSD, OpenBSD >= 5.5.

  3.7 sürümünde geldi.

time.CLOCK_UPTIME_RAW

  Monoton bir şekilde artan saat, istenilen bir noktadan itibaren zamanı takip ediyor, sıklıktan ve zaman ayarlamalarından etkilenmiyor ve sistem uykudayken artmıyor.

  Availability: macOS >= 10.12.

  3.8 sürümünde geldi.

Aşağıdaki sabit `clock_settime()`’a gönderilebilecek tek parametredir.

time.CLOCK_REALTIME

  Sistem çapında gerçek zamanlı saat. Bu saati ayarlamak uygun izinleri gerektirir.

  Availability: Unix.

  3.3 sürümünde geldi.

## Saat dilimi Sabitleri

time.altzone

  Tanımlanmışsa, yerel DST saat diliminin UTC’nin batısındaki saniye cinsinden farkı. Yerel DST saat dilimi UTC’nin doğusundaysa (Britanya dahil Batı Avrupa’da olduğu gibi) bu negatiftir. Bunu yalnızca `daylight` sıfır değilse kullanın. Aşağıdaki nota bakın.

time.daylight

  Sıfırdan farklı, eğer bir DST saat dilimi tanımlanmışsa. Aşağıdaki nota göz atın.

time.timezone

  Yerel (DST olmayan) saat diliminin farkı, UTC’nin batısında saniye cinsinden farkı (Batı Avrupa’nın çoğunda negatif, ABD’de pozitif, Birleşik Krallık’ta sıfır). Aşağıdaki nota bakın.

time.tzname

  İki dizeden oluşan bir demet: ilki yerel DST olmayan saat diliminin ismi, ikincisi yerel DST saat diliminin ismi. DST saat dilimi tanımlanmamışsa, ikinci dize kullanılmamalı. Aşağıdaki nota bakın.

Not

For the above Timezone constants (`altzone`, `daylight`, `timezone`, and `tzname`), the value is determined by the timezone rules in effect at module load time or the last time `tzset()` is called and may be incorrect for times in the past. It is recommended to use the `tm_gmtoff` and `tm_zone` results from `localtime()` to obtain timezone information.

Ayrıca bakınız

`datetime` modülü

  Tarihler ve zamanlar için daha fazla nesne tabanlı arayüz.

`locale` modülü

  Uluslararasılaştırma servisleri. Yerel ayar, `strftime()` ve `strptime()` içindeki birçok biçim belirticisinin yorumlanmasını etkiler.

`calendar` modülü

  Genel takvim ile alakalı fonksiyonlar. `timegm()` bu modüldeki `gmtime()`’in tersidir.

Dipnotlar

[1] (1,2,3)

`%Z` kullanımı artık kullanımdan kaldırıldı, ancak tercih edilen saat/dakika farkına genişleyen `%z` çıkışı, tüm ANSI C kütüphaneleri tarafından desteklenmez. Ayrıca, orijinal 1982 RFC 822 standardının katı bir okuması, iki basamaklı bir yıl gerektirir (`%y` yerine `%y`), ancak uygulama 2000 yılından çok önce 4 basamaklı yıllara taşındı. Bundan sonra RFC 822 geçerliliğini yitirdi ve 4 basamaklı yıl önce RFC 1123 tarafından önerildi ve ardından RFC 2822 tarafından zorunlu kılındı.