"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    | UTC içinde "struct_time"  | "gmtime()"                |
  | beri geçen saniye         |                           |                           |
  +---------------------------+---------------------------+---------------------------+
  | zamanın başlangıcından    | yerel zaman içinde        | "localtime()"             |
  | beri geçen saniye         | "struct_time"             |                           |
  +---------------------------+---------------------------+---------------------------+
  | UTC içinde "struct_time"  | zamanın başlangıcından    | "calendar.timegm()"       |
  |                           | beri geçen saniye         |                           |
  +---------------------------+---------------------------+---------------------------+
  | yerel zaman içinde        | zamanın başlangıcından    | "mktime()"                |
  | "struct_time"             | beri geçen saniye         |                           |
  +---------------------------+---------------------------+---------------------------+


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                 | (1)     |
   |             | [000000,999999].                                 |         |
   +-------------+--------------------------------------------------+---------+
   | "%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    | (4)     |
   |             | 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.            |         |
   +-------------+--------------------------------------------------+---------+
   | "%w"        | Onluk sayı şeklinde hafta içi [0(Sunday),6].     |         |
   +-------------+--------------------------------------------------+---------+
   | "%W"        | Onluk sayı şeklinde yılın (Pazartesi haftanın    | (4)     |
   |             | 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.            |         |
   +-------------+--------------------------------------------------+---------+
   | "%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:

      "J*n*"
         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.

      "M*m*.*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] "%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ı.
