Gömülü Fonksiyonlar¶

Python yorumlayıcısı, içinde gömülü olarak gelen ve her zaman kullanılabilen bir dizi fonksiyon ve tür barındırır. Burada alfabetik sıraya göre listelenmiştir.

Gömülü Fonksiyonlar
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `breakpoint()` `bytearray()` `bytes()` C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` `dict()` `dir()` `divmod()`	E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` `frozenset()` G `getattr()` `globals()` H `hasattr()` `hash()` `help()` `hex()` I `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()`	L `len()` `list()` `locals()` M `map()` `max()` `memoryview()` `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()`	R `range()` `repr()` `reversed()` `round()` S `set()` `setattr()` `slice()` `sorted()` `staticmethod()` `str()` `sum()` `super()` T `tuple()` `type()` V `vars()` Z `zip()` _ `__import__()`

abs(x)¶: Return the absolute value of a number. The argument may be an integer, a floating-point number, or an object implementing __abs__(). If the argument is a complex number, its magnitude is returned.

aiter(async_iterable)¶

Bir asynchronous iterable için bir asynchronous iterator döndürür. x.__aiter__() çağrısına eş değerdir.

Not: iter() ‘in aksine, aiter() ‘in 2 argümanlı biçimi yoktur.

Added in version 3.10.

all(iterable)¶

Eğer iterable ‘ın tüm elementleri doğruysa, True döndürür. Şuna eş değerdir:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

awaitable anext(async_iterator)¶

awaitable anext(async_iterator, default)

Hazır olunduğunda, verilen asynchronous iterator ‘dan sıradaki parçayı döndürür. Eğer yineleyici tükendiyse ve default değer verildiyse, default değeri döndürür.

Bu, gömülü fonksiyonlardan olan next() ‘in asenkron bir varyantıdır, benzer şekilde çalışır.

Bu async_iterator ‘ın __anext__() metodunu çağırır. Bir awaitable döndürür. Bunu beklemek yineleyicinin bir sonraki değerini döndürür. Eğer default değer verildiyse, yineleyici tükendiğinde o döndürülür. Aksi takdirde StopAsyncIteration hatası ortaya çıkar.

Added in version 3.10.

any(iterable)¶

Eğer iterable ‘ın elementlerinden herhangi biri doğru ise True döndürür. Eğer iterable boş ise, False döndürür. Şuna eşittir:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)¶: repr() ‘in bir nesnenin yazdırılabilir temsilini içeren bir dize döndürdüğü, ancak repr() tarafından döndürülen dizedeki ASCII olmayan karakterlerden \x, \u veya \U gibi kaçış karakterlerini kullanarak kaçtığı gibi, bu da Python 2’deki repr() tarafından döndürülen değere benzeyen bir string üretir.

bin(x)¶

Convert an integer number to a binary string prefixed with “0b”. The result is a valid Python expression. If x is not a Python int object, it has to define an __index__() method that returns an integer. Some examples:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

Eğer ön ek olarak “0b” isteniyorsa veya istenmiyorsa, aşağıdaki gibi iki şekilde de kullanabilirsiniz.

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

Ayrıca daha fazla bilgi için format() ‘a bakabilirsiniz.

class bool(object=False, /)¶: Return a Boolean value, i.e. one of True or False. The argument is converted using the standard truth testing procedure. If the argument is false or omitted, this returns False; otherwise, it returns True. The bool class is a subclass of int (see Sayısal Türler — int, float, complex). It cannot be subclassed further. Its only instances are False and True (see Boolean Type - bool).

3.7 sürümünde değişti: The parameter is now positional-only.

breakpoint(*args, **kws)¶

This function drops you into the debugger at the call site. Specifically, it calls sys.breakpointhook(), passing args and kws straight through. By default, sys.breakpointhook() calls pdb.set_trace() expecting no arguments. In this case, it is purely a convenience function so you don’t have to explicitly import pdb or type as much code to enter the debugger. However, sys.breakpointhook() can be set to some other function and breakpoint() will automatically call that, allowing you to drop into the debugger of choice. If sys.breakpointhook() is not accessible, this function will raise RuntimeError.

By default, the behavior of breakpoint() can be changed with the PYTHONBREAKPOINT environment variable. See sys.breakpointhook() for usage details.

Note that this is not guaranteed if sys.breakpointhook() has been replaced.

Raises an auditing event builtins.breakpoint with argument breakpointhook.

Added in version 3.7.

class bytearray(source=b'')

class bytearray(source, encoding)

class bytearray(source, encoding, errors)

Baytlardan oluşan yeni bir dizi döndürür. bytearray sınıfı 0 <= x < 256 aralığındaki tam sayılardan oluşan değişebilir bir dizedir. Değiştirilebilir Dizi Tipleri ‘da tarif edildiği gibi değişebilir dizeler klasik metotlarının çoğuna sahiptir. bytes tipinin sahip olduğu metotlar için, Bytes and Bytearray Operations ‘a bakınız.

Opsiyonel source parametresi diziyi birkaç farklı şekilde başlatmak için kullanılabilir:

Eğer bir string ise, encoding (ve istenirse, errors) parametrelerini de vermelisiniz; sonrasında bytearray() str.encode() kullanarak dizeyi bayta çevirecektir.
Eğer bir integer ise, dizi bu boyuta göre null baytlar ile doldurulur.
Eğer arabellek arayüzü ‘ne uyan bir objeyse, bayt dizisini başlatmak için bir salt okunur arabellek kullanılır.
Eğer iterable ise, 0 <= x < 256 aralığındaki dizinin başlangıç içeriği olan tam sayılardan oluşan bir yinelenebilir nesne olmalıdır.

Argüman yoksa, boyutu 0 olan bir dizi oluşturulur.

Binary Sequence Types — bytes, bytearray, memoryview ve Bytearray Objects ‘a bakınız.

class bytes(source=b'')

class bytes(source, encoding)

class bytes(source, encoding, errors)

0 <= x < 256 aralığındaki tam sayılardan oluşan değiştirilemez bir “bayt” objesi döndürür. bytes, bytearray ‘in değiştirilemez versiyonudur. Aynı objeyi değiştirmeyen metotlara, indeksleme ve dilimleme davranışına sahiptir.

Buna göre, yapıcı argümanları bytearray() için yorumlanır.

Bayt nesneleri değişmez değerler ile de oluşturulabilir, String and Bytes literals ‘a bakınız.

Ayrıca Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects, ve Bytes and Bytearray Operations ‘a bakınız.

callable(object)¶: Return True if the object argument appears callable, False if not. If this returns True, it is still possible that a call fails, but if it is False, calling object will never succeed. Note that classes are callable (calling a class returns a new instance); instances are callable if their class has a __call__() method.

Added in version 3.2: Bu fonksiyon Python 3.0 versiyonunda kaldırılmıştı ama Python 3.2 versiyonunda geri getirildi.

chr(i)¶

Unicode kod noktası i tamsayısı olan bir karakteri temsil eden dizeyi döndürür. Örneğin, chr(97) , 'a' dizesini döndürürken, chr(8364) , '€' dizesini döndürür. Bu fonksiyon, ord() ‘un tam tersidir.

Argüman için geçerli değer 0 ile 1.114.111 arasındadır (16’lık sayı sisteminde 0x10FFFF). Eğer i aralığın dışında ise ValueError hatası ortaya çıkar.

@classmethod¶

Bir metodu sınıf metoduna dönüştürür.

Bir sınıf metodu, sınıfı örtük ilk argüman olarak alır, aynı sınıftan türeyen bir örneğin metodunun örneği aldığı gibi. Bir sınıf metodunu bu şekilde tanımlayabilirsiniz:

class C:
    @classmethod
    def f(cls, arg1, arg2): ...

@classmethod formu, bir decorator fonksiyonudur. – detaylar için Function definitions ‘a bakınız.

Bir sınıf metodu sınıf (C.f() gibi) veya örnek (C().f() gibi) üzerinden çağırılabilir. Örnek, sınıfı dışında yoksayılır. Eğer bir sınıf metodu türetilmiş bir sınıf için çağrılırsa, türetilmiş sınıf nesnesi örtük ilk argüman olarak geçer.

Sınıf metotları C++ ve Java static metotlarından farklıdır. Eğer bunları kullanmak isterseniz, bu bölümdeki staticmethod() kısmına bakınız. Sınıf metotları hakkında daha fazla bilgi için, The standard type hierarchy ‘a bakınız.

3.9 sürümünde değişti: Sınıf metotları artık property() gibi diğer descriptors ‘ları sarmalayabilir.

3.10 sürümünde değişti: Class methods now inherit the method attributes (__module__, __name__, __qualname__, __doc__ and __annotations__) and have a new __wrapped__ attribute.

Deprecated since version 3.11, removed in version 3.13: Sınıf metotları artık property() gibi diğer descriptor ‘ları sarmalayamaz.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)¶

source ‘ı bir koda veya AST nesnesine derler. Kod nesneleri exec() veya eval() fonksiyonları kullanılarak çalıştırılabilir. source normal bir dize, bayt dizesi veya bir AST nesnesi olabilir. AST nesneleriyle nasıl çalışılacağını öğrenmek için ast modülüne bkz.

filename argümanı kodun okunduğu dosyayı vermelidir; eğer bir dosyadan okunmuyorsa ayırtedilebilir bir değer verebilirsin (genellikle '<string>' kullanılır).

mode argümanı hangi türden kodun derleneceğini belirtir; eğer source bir dizi ifadeden oluşuyorsa 'exec' , eğer tek bir ifadeden oluşuyorsa 'eval' , veya tek bir etkileşimli ifadeden oluşuyorsa 'single' olabilir (ikinci durumda, “None” dışında bir değere sahip ifadeler yazdırılacaktır).

flags ve dont_inherit opsiyonel argümanları hangi derleyici seçenekleri ‘ın aktive edilmesi gerektiğini ve hangi gelecekteki özellikler ‘e izin verileceğini kontrol eder. İkisi de verilmediyse (veya ikisi de sıfır ise) kod, compile() ‘ı çağıran kodu etkileyen aynı bayraklarla derlenir. Eğer flags argümanı verilip dont_inherit verilmediyse (veya sıfırsa), derleyici seçenekleri ve gelecek ifadeleri flags argümanı tarafından belirtilirler, her türlükullanılacak olanlara ek olarak kullanılır. Eğer dont_inherit sıfırdan farklı bir tamsayıysa, flags argümanı da odur. – çevreleyen koddaki bayraklar (gelecekteki özellikler ve derleyici seçenekleri) yoksayılır.

Derleyici seçenekleri ve gelecek ifadeleri, birden fazla seçeneği belirlemek için bit düzeyinde VEYA’lanabilen bitler tarafından belirlenirler. Gelecekteki belirli bir özelliği belirtmek için gereken bit alanı, __future__ modülündeki _Feature örneğinde compiler_flag niteliği olarak bulunabilir. Derleyici bayrakları , ast modülünde PyCF_ öneki ile bulunabilir.

optimize argümanı derleyicinin optimizasyon seviyesini belirler; -1 varsayılan değeri, -O seçenekleri tarafından verilen yorumlayıcının optimizasyon seviyesini seçer. Belli seviyeler: 0 (optimizasyon yok; __debug__ doğru), 1 (iddialar kaldırılır, __debug__ yanlış) veya 2 (Ekstradan doküman dizeleri de kaldırıldı).

Bu fonksiyon derlenmiş kaynak geçerli değil ise SyntaxError , null baytlar içeriyorsa ValueError hatalarını ortaya çıkarır.

Python kodunu onun AST temsiline ayrıştırmak isterseniz, ast.parse() ‘a bakınız.

source ve filename argümanlarıyla denetleme olayı compile ortaya çıkartır. Bu durum, örtük derleme ile de ortaya çıkarılabilir.

Not

'single' veya 'eval' modunda çok satırlı bir dize derleneceğinde, giren veri en az bir yeni satır karakteri ile sonlandırılmalıdır. Bu code modülündeki tamamlanmış ve tamamlanmamış ifadelerin tespitini kolaylaştırmak içindir.

Uyarı

Python’un AST derleyicisindeki yığın derinliği sınırlamaları nedeniyle yeterince büyük/karmaşık bir dizeyi bir AST nesnesine derlerken Python yorumlayıcısını çökertmek mümkündür.

3.2 sürümünde değişti: Windows ve Mac yeni satırlarının kullanımına izin verildi. Ayrıca, bundan böyle 'exec' modunda iken veri girişinin yeni satırda sonlanması gerekmiyor. optimize parametresi eklendi.

3.5 sürümünde değişti: Önceden, source , null baytlar içeriyorsa TypeError hatası ortaya çıkardı.

Added in version 3.8: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT artık üst düze await, async for, ve async with desteğini etkinleştirmek için bayraklarla iletilebilir.

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

Convert a single string or number to a complex number, or create a complex number from real and imaginary parts.

Examples:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

If the argument is a string, it must contain either a real part (in the same format as for float()) or an imaginary part (in the same format but with a 'j' or 'J' suffix), or both real and imaginary parts (the sign of the imaginary part is mandatory in this case). The string can optionally be surrounded by whitespaces and the round parentheses '(' and ')', which are ignored. The string must not contain whitespace between '+', '-', the 'j' or 'J' suffix, and the decimal number. For example, complex('1+2j') is fine, but complex('1 + 2j') raises ValueError. More precisely, the input must conform to the complexvalue production rule in the following grammar, after parentheses and leading and trailing whitespace characters are removed:

complexvalue ::=  floatvalue |
                  floatvalue ("j" | "J") |
                  floatvalue sign absfloatvalue ("j" | "J")

If the argument is a number, the constructor serves as a numeric conversion like int and float. For a general Python object x, complex(x) delegates to x.__complex__(). If __complex__() is not defined then it falls back to __float__(). If __float__() is not defined then it falls back to __index__().

If two arguments are provided or keyword arguments are used, each argument may be any numeric type (including complex). If both arguments are real numbers, return a complex number with the real component real and the imaginary component imag. If both arguments are complex numbers, return a complex number with the real component real.real-imag.imag and the imaginary component real.imag+imag.real. If one of arguments is a real number, only its real component is used in the above expressions.

If all arguments are omitted, returns 0j.

Karmaşık tür, Sayısal Türler — int, float, complex kısmında açıklanmıştır.

3.6 sürümünde değişti: Rakamların, kod sabitlerinde olduğu gibi alt çizgi ile gruplandırılmasına izin verilir.

3.8 sürümünde değişti: Falls back to __index__() if __complex__() and __float__() are not defined.

delattr(object, name)¶: setattr() fonksiyonu ile ilişkilidir . Argümanlar bir nesne ve bir dizedir. Dize nesnenin özelliklerinden birinin adı olmak zorundadır. Fonksiyon nesnenin izin vermesi koşuluyla, dizede belirtilen bu özelliği siler. Örnek olarak, delattr(x, 'foobar') , del x.foobar ‘a eş değerdir. name bir Python tanımlayıcısı olmak zorunda değildir (setattr() bkz.).

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Yeni bir sözlük yaratır. dict nesnesi bir sözlük sınıfıdır. Bu sınıf hakkındaki dokümantasyon için dict ve Mapping Types — dict ‘e bakınız.

Diğer konteynerler için dahili list , set , tuple sınıfları ve collections modülüne bakınız.

dir()¶

dir(object)

Argüman yoksa, mevcut yerel kapsamdaki isimleri liste olarak döndürür. Argüman varsa, o nesne için geçerli özelliklerin bir listesini döndürmeye çalışır.

If the object has a method named __dir__(), this method will be called and must return the list of attributes. This allows objects that implement a custom __getattr__() or __getattribute__() function to customize the way dir() reports their attributes.

If the object does not provide __dir__(), the function tries its best to gather information from the object’s __dict__ attribute, if defined, and from its type object. The resulting list is not necessarily complete and may be inaccurate when the object has a custom __getattr__().

Varsayılan dir() mekanizması, eksiksiz bilgi yerine en alakalı bilgiyi üretmeye çalıştığı için farklı nesne türleriyle farklı çalışır:

Eğer nesne bir modül nesnesiyse, liste modülün özelliklerinin isimlerini içerir.
Eğer nesne bir tür veya sınıf nesnesiyse, liste onun özelliklerini ve yinelemeli olarak tabanlarının özelliklerini içerir.
Aksi takdirde, liste nesnenin özelliklerini, sınıfının özelliklerini ve yinelemeli olarak sınıfının temel sınıflarının özelliklerini içerir.

Sonuç listesi alfabetik olarak sıralanmıştır. Örnek olarak:

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
...
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Not

Çünkü dir(), öncelikle etkileşimli bir komut isteminde kullanım kolaylığı sunmak amacıyla sağlanır. Titizlikle ve tutarlı bir isim kümesi sağlamaktansa ilginç bir isim kümesi sağlar, Detaylı davranışlı sürümler arasında değişikliğe uğrayabilir. Örnek olarak, argüman sınıf ise metasınıf özellikleri sonuç listesinde yer almaz.

divmod(a, b)¶: Take two (non-complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using integer division. With mixed operand types, the rules for binary arithmetic operators apply. For integers, the result is the same as (a // b, a % b). For floating-point numbers the result is (q, a % b), where q is usually math.floor(a / b) but may be 1 less than that. In any case q * b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)¶

Bir numaralandırma nesnesi döndürür. iterable bir dize, iterator veya tekrarlamayı destekleyen başka bir nesne olmalıdır. Yineleyicinin by enumerate() tarafından döndürülen __next__() metodu bir sayıyı (varsayılan olarak 0 olan start ‘dan) ve iterable üzerinde yinelemeden elde edilen değerleri içeren bir demet döndürür.

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Şuna eşittir:

def enumerate(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval(source, /, globals=None, locals=None)¶

Parametreler:

source (str | code object) – A Python expression.
globals (dict | None) – The global namespace (default: None).
locals (mapping | None) – The local namespace (default: None).

Dönüşler:

The result of the evaluated expression.

Raises:

Syntax errors are reported as exceptions.

Uyarı

This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.

The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals mappings as global and local namespace. If the globals dictionary is present and does not contain a value for the key __builtins__, a reference to the dictionary of the built-in module builtins is inserted under that key before expression is parsed. That way you can control what builtins are available to the executed code by inserting your own __builtins__ dictionary into globals before passing it to eval(). If the locals mapping is omitted it defaults to the globals dictionary. If both mappings are omitted, the expression is executed with the globals and locals in the environment where eval() is called. Note, eval() will only have access to the nested scopes (non-locals) in the enclosing environment if they are already referenced in the scope that is calling eval() (e.g. via a nonlocal statement).

Example:

>>> x = 1
>>> eval('x+1')
2

Bu fonksiyon keyfi kod nesnelerini (compile() tarafından oluşturulanlar gibi) çalıştırmak için de kullanılabilir. Bu durumda, dize yerine bir kod nesnesi iletin. Eğer kod nesnesi mode argümanı olarak 'exec' ile derlendiyse, eval() ‘in döndürdüğü değer None olacaktır.

İpuçları: ifadelerin dinamik yürütmeleri exec() fonksiyonu tarafından desteklenir. globals() ve locals() fonksiyonları sırasıyla mevcut global ve yerel sözlüğü döndürür. eval() veya exec() tarafından kullanım için dolaşmak yararlı olabilir.

Eğer verilen kaynak dize ise, baştaki ve sondaki boşluklar ve tab’lar çıkarılır.

Sadece kalıp içeren ifadelerle dizeleri güvenli bir şekilde değerlendirebilen bir fonksiyon arıyorsanız, ast.literal_eval() ‘a bakınız.

Argüman olarak kod nesnesi ile bir denetleme olayı exec hatası ortaya çıkartır. Kodun derlendiği sırada çıkan hatalar da yükseltilir.

3.13 sürümünde değişti: The globals and locals arguments can now be passed as keywords.

3.13 sürümünde değişti: The semantics of the default locals namespace have been adjusted as described for the locals() builtin.

exec(source, /, globals=None, locals=None, *, closure=None)¶

Uyarı

This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.

This function supports dynamic execution of Python code. source must be either a string or a code object. If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs). [1] If it is a code object, it is simply executed. In all cases, the code that’s executed is expected to be valid as file input (see the section File input in the Reference Manual). Be aware that the nonlocal, yield, and return statements may not be used outside of function definitions even within the context of code passed to the exec() function. The return value is None.

In all cases, if the optional parts are omitted, the code is executed in the current scope. If only globals is provided, it must be a dictionary (and not a subclass of dictionary), which will be used for both the global and the local variables. If globals and locals are given, they are used for the global and local variables, respectively. If provided, locals can be any mapping object. Remember that at the module level, globals and locals are the same dictionary.

Not

When exec gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition. This means functions and classes defined in the executed code will not be able to access variables assigned at the top level (as the “top level” variables are treated as class variables in a class definition).

Eğer globals sözlüğü __builtins__ anahtarı için bir değer içermiyorsa, bu anahtarın altına bir referans yerleşik modül builtins ‘in sözlüğüne eklenir. Bu şekilde, kendi __builtins__ sözlüğünüzü exec() ‘e geçirmeden önce globals içine ekleyerek yürütülen kod için hangi yerleşiklerin mevcut olduğunu kontrol edebilirsiniz.

The closure argument specifies a closure–a tuple of cellvars. It’s only valid when the object is a code object containing free (closure) variables. The length of the tuple must exactly match the length of the code object’s co_freevars attribute.

Argüman olarak kod nesnesi ile bir denetleme olayı exec hatası ortaya çıkartır. Kodun derlendiği sırada çıkan hatalar da yükseltilir.

Not

The built-in functions globals() and locals() return the current global and local namespace, respectively, which may be useful to pass around for use as the second and third argument to exec().

Not

The default locals act as described for function locals() below. Pass an explicit locals dictionary if you need to see effects of the code on locals after function exec() returns.

3.11 sürümünde değişti: closure parametresi eklendi.

3.13 sürümünde değişti: The globals and locals arguments can now be passed as keywords.

3.13 sürümünde değişti: The semantics of the default locals namespace have been adjusted as described for the locals() builtin.

filter(function, iterable)¶

fonksiyon’un doğru olduğu iterable öğelerinden bir yineleyici oluşturun. iterable bir dizi, yinelemeyi destekleyen bir kapsayıcı veya bir yineleyici olabilir. fonksiyon None ise, kimlik işlevi varsayılır, yani iterable öğesinin yanlış olan tüm öğeleri kaldırılır.

Eğer fonksiyon None değilse ve (item for item in iterable if item) için fonksiyon None ise, filter(function, iterable) ‘ın bir üretici ifadesine (item for item in iterable if function(item)) eşit olduğunu unutmayın.

fonksiyon’un yanlış olduğu iterable öğelerini döndüren tamamlayıcı fonksiyon için itertools.filterfalse() konusuna bakın.

class float(number=0.0, /)¶

class float(string, /)

Return a floating-point number constructed from a number or a string.

Examples:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

If the argument is a string, it should contain a decimal number, optionally preceded by a sign, and optionally embedded in whitespace. The optional sign may be '+' or '-'; a '+' sign has no effect on the value produced. The argument may also be a string representing a NaN (not-a-number), or positive or negative infinity. More precisely, the input must conform to the floatvalue production rule in the following grammar, after leading and trailing whitespace characters are removed:

sign          ::=  "+" | "-"
infinity      ::=  "Infinity" | "inf"
nan           ::=  "nan"
digit         ::=  <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart     ::=  digit (["_"] digit)*
number        ::=  [digitpart] "." digitpart | digitpart ["."]
exponent      ::=  ("e" | "E") [sign] digitpart
floatnumber   ::=  number [exponent]
absfloatvalue ::=  floatnumber | infinity | nan
floatvalue    ::=  [sign] absfloatvalue

Case is not significant, so, for example, “inf”, “Inf”, “INFINITY”, and “iNfINity” are all acceptable spellings for positive infinity.

Otherwise, if the argument is an integer or a floating-point number, a floating-point number with the same value (within Python’s floating-point precision) is returned. If the argument is outside the range of a Python float, an OverflowError will be raised.

For a general Python object x, float(x) delegates to x.__float__(). If __float__() is not defined then it falls back to __index__().

Argüman verilmediyse, 0.0 döndürülür.

Float tipi Sayısal Türler — int, float, complex kısmında açıklandı.

3.6 sürümünde değişti: Rakamların, kod sabitlerinde olduğu gibi alt çizgi ile gruplandırılmasına izin verilir.

3.7 sürümünde değişti: The parameter is now positional-only.

3.8 sürümünde değişti: Falls back to __index__() if __float__() is not defined.

format(value, format_spec='')¶

Bir value ‘ı, format_spec tarafından kontrol edildiği gibi “biçimlendirilmiş” bir gösterime dönüştürür. format_spec ‘in yorumlanması value argümanının tipine göre değişkendir; ama, çoğu yerleşik tiplerde kullanılan Format Specification Mini-Language adında bir standart biçimlendirme sözdizimi var.

Varsayılan format_spec, str(value) fonksiyonunu çağırmakla aynı etkiyi gösteren boş bir dizedir.

A call to format(value, format_spec) is translated to type(value).__format__(value, format_spec) which bypasses the instance dictionary when searching for the value’s __format__() method. A TypeError exception is raised if the method search reaches object and the format_spec is non-empty, or if either the format_spec or the return value are not strings.

3.4 sürümünde değişti: format_spec boş bir dize değilse, object().__format__(format_spec), TypeError hatasını ortaya çıkartır.

class frozenset(iterable=set())

Opsiyonel olarak iterable öğesinden alınan öğelerle yeni bir frozenset nesnesi döndürür. frozenset yerleşik bir sınıftır. Bu sınıf hakkında dokümantasyona ulaşmak için frozenset ve Set Türleri — set, frozenset ‘e bakınız.

Diğer konteynerler için, yerleşik set, list, tuple, ve dict sınıflarına, ayrıca collections modülüne bakabilirsiniz.

getattr(object, name)¶
getattr(object, name, default): object ‘in parametre olarak verilmiş isimli özelliğinin değerini döndürür. name bir dize olmalıdır. Eğer dize nesnenin özelliklerinden birinin ismi ise, sonuç bu özelliğin değeri olur. Örnek olarak, getattr(x, 'foobar'), x.foobar ‘a eşittir. Eğer isimlendirilmiş özellik objede bulunmuyorsa, default sağlanmışsa döndürülür, aksi takdirde AttributeError hatası ortaya çıkar. name bir Python tanımlayıcısı olmak zorunda değildir (setattr() bkz).

Not

özel isim yönetimi derleme zamanında gerçekleştiğinden dolayı, getattr() ile almak için özel bir niteliğin (baştaki iki alt çizgili nitelikler) adını manuel olarak değiştirmek gerekir.

globals()¶: Geçerli modül ad alanını uygulayan sözlüğü döndürür. Fonksiyonlar içeren kod için, bu fonksiyon tanımlandığında ayarlanır ve fonksiyonun çağrıldığı yerden bağımsız olarak aynı kalır.

hasattr(object, name)¶: Argümanlar bir nesne ve dizedir. Eğer dize, nesnenin özelliklerinden birinin ismiyse True, değilse False döndürür. (Bu getattr(object, name) ‘i çağırarak uygulanır ve AttributeError hatası oluşup oluşmayacağı görülür.)

hash(object)¶: Nesnenin karma değerini döndürür (eğer varsa). Karma değerler tam sayılardır. Sözlükleri incelerken hızlı bir şekilde anahtarları karşılaştırmak için kullanılırlar. Karşılaştırıldığında aynı olan nümerik değerler aynı karma değere sahiptir (1 ve 1.0 durumunda olduğu gibi farklı veri tiplerinde olsalar bile).

Not

For objects with custom __hash__() methods, note that hash() truncates the return value based on the bit width of the host machine.

help()¶

help(request)

Yerleşik yardım sistemini çağırın. (Bu fonksiyon interaktif kullanıma yöneliktir.) Eğer argüman verilmediyse, interaktif yardım sistemi yorumlayıcı konsolunda başlar. Eğer argüman bir dize ise, bir modül, fonksiyon, sınıf, metot, anahtar kelime veya dokümantasyon konusu için dizeye bakılır ve bir yardım sayfası konsola bastırılır. Eğer argüman başka tipte bir nesne ise, nesne üzerinde bir yardım sayfası oluşturulur.

Eğer help() çağrılırken bir fonksiyonun parametre listesinde eğik çizgi(/) bulunuyorsa, bu, eğik çizgiden önceki parametrelerin yalnızca konumsal olduğu anlamına gelir. Daha fazla bilgi için yalnızca konumsalparametrelerle ilgili SSS girişi ‘ne bakınız.

Bu fonksiyon site modülü tarafından yerleşik ad alanına eklenir.

3.4 sürümünde değişti: pydoc ve inspect ‘e gelen değişiklikler, çağrılabilir nesneler için rapor edilen damgaların artık daha kapsamlı ve tutarlı olduğunu ifade eder.

hex(x)¶

Convert an integer number to a lowercase hexadecimal string prefixed with “0x”. If x is not a Python int object, it has to define an __index__() method that returns an integer. Some examples:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

Eğer bir tam sayıyı büyük harf-küçük harf, önekli-öneksiz bir onaltılık sayıya dönüştürmek istiyorsanız, aşağıdaki yolları kullanabilirsiniz:

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

Ayrıca daha fazla bilgi için format() ‘a bakabilirsiniz.

Ayrıca onaltılık bir dizgiyi 16 tabanını kullanarak bir tam sayıya dönüştürmek için int() ‘e bakınız.

Not

Bir gerçel sayıdan onaltılık bir dize gösterimi elde etmek için float.hex() metodunu kullanın.

id(object)¶

Bir nesnenin “kimlik” ‘ini döndürür. Bu nesnenin ömrü boyunca eşsiz ve sabit olduğu garanti edilen bir tam sayıdır. Ömürleri örtüşmeyen iki nesne aynı id() değerine sahip olabilir.

CPython uygulama ayrıntısı: Bu, bellekteki nesnenin adresidir.

Raises an auditing event builtins.id with argument id.

input()¶

input(prompt)

Eğer prompt argümanı bulunuyorsa, sonunda yeni bir satır olmadan standart çıktıya yazılır. Ardından fonksiyon veri girişinden bir satır okur ve bunu bir dizeye çevirip (sondaki yeni satırı çıkartır) döndürür. EOF okunduğunda, EOFError istisnası ortaya çıkar. Örnek:

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

Eğer readline modülü yüklendiyse, input() ayrıntılı satır düzenleme ve geçmiş özellikleri sağlamak için onu kullanacaktır.

Girişi okumadan önce, prompt argümanıyla birlikte bir denetleme olayı builtins.input ortaya çıkartır

Girişi başarıyla okuduktan sonra sonuçla birlikte bir auditing event builtins.input/result denetleme olayı ortaya çıkarır.

class int(number=0, /)¶

class int(string, /, base=10)

Return an integer object constructed from a number or a string, or return 0 if no arguments are given.

Examples:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

If the argument defines __int__(), int(x) returns x.__int__(). If the argument defines __index__(), it returns x.__index__(). If the argument defines __trunc__(), it returns x.__trunc__(). For floating-point numbers, this truncates towards zero.

If the argument is not a number or if base is given, then it must be a string, bytes, or bytearray instance representing an integer in radix base. Optionally, the string can be preceded by + or - (with no space in between), have leading zeros, be surrounded by whitespace, and have single underscores interspersed between digits.

Bir taban-n tamsayı dizesi, her biri 0 ile n-1 arasında bir değeri temsil eden rakamlar içerir. 0–9 değerleri herhangi bir Unicode ondalık basamağı ile temsil edilebilir. 10-35 değerleri a ila z (veya A ila Z) ile temsil edilebilir. Varsayılan taban 10’dur. İzin verilen tabanlar 0 ve 2–36’dır. Taban-2, -8 ve -16 dizelerinin önüne isteğe bağlı olarak 0b/0B, 0o/0O veya 0x/0X eklenebilir, tıpkı koddaki tamsayı değişmezlerinde olduğu gibi. Taban 0 için, dize koddaki tamsayı değişmezi ‘ne benzer bir şekilde yorumlanır, gerçek taban önek tarafından belirlenen 2, 8, 10 veya 16’dır. Taban 0 ayrıca baştaki sıfırlara da izin vermez: int('010', 0) yasal değilken, int('010') ve int('010', 8) yasaldır.

Tam sayı tipi Sayısal Türler — int, float, complex kısmında açıklandı.

3.4 sürümünde değişti: Eğer base bir int örneği değilse ve base objesi base.__index__ metoduna sahipse, bu metot, taban için bir tamsayı elde etmek için çağrılır. Önceki sürümler base.__index__ yerine base.__int__ ‘i kullandı.

3.6 sürümünde değişti: Rakamların, kod sabitlerinde olduğu gibi alt çizgi ile gruplandırılmasına izin verilir.

3.7 sürümünde değişti: The first parameter is now positional-only.

3.8 sürümünde değişti: Falls back to __index__() if __int__() is not defined.

3.11 sürümünde değişti: The delegation to __trunc__() is deprecated.

3.11 sürümünde değişti: int string inputs and string representations can be limited to help avoid denial of service attacks. A ValueError is raised when the limit is exceeded while converting a string to an int or when converting an int into a string would exceed the limit. See the integer string conversion length limitation documentation.

isinstance(object, classinfo)¶: object argümanı, classinfo argümanının bir örneğiyse veya (doğrudan, dolaylı veya sanal) alt sınıfının bir örneğiyse True döndürür. Eğer object verilen tipte bir nesne değilse, fonksiyon mutlaka False döndürür. classinfo, tür nesnelerinden oluşan bir demet (veya yinelemeli olarak, bu tür diğer demetler) veya birden çok türden bir Sendika Türü ise, ayrıca object bu verilen türlerden herhangi birinin örneği ise True döndürür. Eğer classinfo bir tür veya türler içeren bir tuple değilse, TypeError hatası ortaya çıkar. Eğer önceden yapılmış bir kontrol başarılıysa TypeError geçersiz bir tip için ortaya çıkmayabilir.

3.10 sürümünde değişti: classinfo bir Sendika Türü olabilir.

issubclass(class, classinfo)¶: Eğer class, classinfo ‘nun bir alt sınıfıysa (doğrudan, dolaylı, veya sanal), True döndürür. Bir sınıf kendisinin alt sınıfı olarak dikkate alınır. classinfo sınıf nesnelerinden oluşan bir demet (veya tekrarlı diğer benzer demetler) veya Sendika Türü olabilir, bu durumda eğer class, classinfo ‘daki elemanlardan herhangi birinin alt sınıfıysa True döndürülür. Diğer her durumda, TypeError hatası ortaya çıkar.

3.10 sürümünde değişti: classinfo bir Sendika Türü olabilir.

iter(object)¶

iter(object, sentinel)

Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, object must be a collection object which supports the iterable protocol (the __iter__() method), or it must support the sequence protocol (the __getitem__() method with integer arguments starting at 0). If it does not support either of those protocols, TypeError is raised. If the second argument, sentinel, is given, then object must be a callable object. The iterator created in this case will call object with no arguments for each call to its __next__() method; if the value returned is equal to sentinel, StopIteration will be raised, otherwise the value will be returned.

Ayrıca Yineleyici Türleri bkz.

iter() ‘in ikinci formunun kullanışlı uygulamalarından biri bir blok okuyucu inşaa etmektir. Örnek olarak, dosyanın sonuna ulaşılana kadar ikili bir veritabanı dosyasından sabit genişlikte bloklar okunurken:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

len(s)¶: Bir objenin uzunluğunu (element sayısını) döndürür. Argüman bir dizi (örneğin dize, bytes, demet, liste veya aralık) veya bir koleksiyon (örneğin sözlük, küme veya dondurulmuş küme) olabilir.

CPython uygulama ayrıntısı: len, range(2 ** 100) gibi sys.maxsize ‘dan daha geniş uzunluklar için OverflowError hatası ortaya çıkartır.

class list
class list(iterable): Bir fonksiyon görevi görmektense, Listeler ve Dizi Tipleri — list, tuple, range de anlatıldığı gibi list bir değiştirebilir dizi çeşididir.

locals()¶: Return a mapping object representing the current local symbol table, with variable names as the keys, and their currently bound references as the values.

At module scope, as well as when using exec() or eval() with a single namespace, this function returns the same namespace as globals().

At class scope, it returns the namespace that will be passed to the metaclass constructor.

When using exec() or eval() with separate local and global arguments, it returns the local namespace passed in to the function call.

In all of the above cases, each call to locals() in a given frame of execution will return the same mapping object. Changes made through the mapping object returned from locals() will be visible as assigned, reassigned, or deleted local variables, and assigning, reassigning, or deleting local variables will immediately affect the contents of the returned mapping object.

In an optimized scope (including functions, generators, and coroutines), each call to locals() instead returns a fresh dictionary containing the current bindings of the function’s local variables and any nonlocal cell references. In this case, name binding changes made via the returned dict are not written back to the corresponding local variables or nonlocal cell references, and assigning, reassigning, or deleting local variables and nonlocal cell references does not affect the contents of previously returned dictionaries.

Calling locals() as part of a comprehension in a function, generator, or coroutine is equivalent to calling it in the containing scope, except that the comprehension’s initialised iteration variables will be included. In other scopes, it behaves as if the comprehension were running as a nested function.

Calling locals() as part of a generator expression is equivalent to calling it in a nested generator function.

3.12 sürümünde değişti: The behaviour of locals() in a comprehension has been updated as described in PEP 709.

3.13 sürümünde değişti: As part of PEP 667, the semantics of mutating the mapping objects returned from this function are now defined. The behavior in optimized scopes is now as described above. Aside from being defined, the behaviour in other scopes remains unchanged from previous versions.

map(function, iterable, *iterables)¶: iterable ‘in her elementini function ‘a gönderen bir yineleyici döndürür ve sonuçları sunar. Eğer ek iterables parametreleri verildiyse, function o sayıda parametre almalı ve paralel bir şekilde tüm yinelenebilir nesnelerden tüm elementleri uygulamalıdır. Birden fazla yinelenebilir nesne ile, yineleyici en kısa yinelenebilir nesne tükendiğinde durur. Fonksiyon girdilerinin zaten demetler halinde verildiği durumlar için, itertools.starmap()‘a bakın.

max(iterable, *, key=None)¶

max(iterable, *, default, key=None)

max(arg1, arg2, *args, key=None)

Bir yineleyicinin veya birden fazla parametrenin en büyük elementini döndürür.

Eğer bir konumsal parametre sağlandıysa, o bir iterable olmalıdır. Yineleyicinin en büyük elementi döndürülür. Eğer iki veya daha fazla pozisyonel parametre sağlandıysa, pozisyonel parametrelerin en büyüğü döndürülür.

İki tane opsiyonel anahtar kelime parametresi vardır. key parametresi, list.sort() için kullanıldığı gibi bir parametre talep etme fonksiyonunu belirtir. varsayılan parametre, sağlanan yineleyici boş ise döndürülecek nesneyi belirtir. Eğer yineleyici boş ve varsayılan verilmemiş ise, ValueError hatası ortaya çıkar.

Eğer birden fazla element en büyük ise, fonksiyon ilk rastlananı döndürür. bu sorted(iterable, key=keyfunc, reverse=True)[0] ve heapq.nlargest(1, iterable, key=keyfunc) gibi sıralama kararlılığı muhafaza eden araçlar ile uygundur.

3.4 sürümünde değişti: Added the default keyword-only parameter.

3.8 sürümünde değişti: key None olabilir.

class memoryview(object): Verilen argümandan oluşturulan bir “memory view” objesi döndürür. Daha fazla bilgi için Memory Views bkz.

min(iterable, *, key=None)¶

min(iterable, *, default, key=None)

min(arg1, arg2, *args, key=None)

Bir yineleyicideki en küçük elementi veya birden fazla argümandan en küçüğünü döndürür.

Eğer bir argüman sağlandıysa, argüman bir iterable olmalıdır. Yineleyicinin en küçük elementi döndürülür. Eğer birden fazla argüman sağlandıysa, argümanların en küçüğü döndürülür.

İki tane opsiyonel anahtar kelime parametresi vardır. key parametresi, list.sort() için kullanıldığı gibi bir parametre talep etme fonksiyonunu belirtir. varsayılan parametre, sağlanan yineleyici boş ise döndürülecek nesneyi belirtir. Eğer yineleyici boş ve varsayılan verilmemiş ise, ValueError hatası ortaya çıkar.

Eğer birden fazla element minimum ise, ilk karşılaşılan döndürülür. Bu, sorted(iterable, key=keyfunc)[0] ve heapq.nsmallest(1, iterable, key=keyfunc) gibi diğer sıralama kararlılığını koruma araçlarıyla tutarlı çalışır.

3.4 sürümünde değişti: Added the default keyword-only parameter.

3.8 sürümünde değişti: key None olabilir.

next(iterator)¶
next(iterator, default): iterator ‘ın __next__() metodunu çağırarak sıradaki elementi getirir. Eğer default verildiyse ve yineleyici tükenmiş ise default döndürülür, aksi takdirde StopIteration hatası ortaya çıkar.

class object¶: This is the ultimate base class of all other classes. It has methods that are common to all instances of Python classes. When the constructor is called, it returns a new featureless object. The constructor does not accept any arguments.

Not

object instances do not have __dict__ attributes, so you can’t assign arbitrary attributes to an instance of object.

oct(x)¶

Convert an integer number to an octal string prefixed with “0o”. The result is a valid Python expression. If x is not a Python int object, it has to define an __index__() method that returns an integer. For example:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

Eğer bir tamsayıyı “0o” ön ekiyle veya ön eksiz oktal bir dizeye dönüştürmek istiyorsanız, aşağıdaki yolları kullanabilirsiniz.

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

Ayrıca daha fazla bilgi için format() ‘a bakabilirsiniz.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)¶

file ‘ı açar ve buna karşılık gelen file object ‘i döndürür. Eğer dosya açılamazsa, OSError hatası ortaya çıkar. Bu fonksiyonun nasıl kullanıldığına dair daha fazla örnek için Dosyaları Okuma ve Yazma bkz.

file, açılan dosyanın açılması veya dosyanın bir tam sayı dosya tanımlayıcısının paketlenmesi için bir yol adını (mutlak veya geçerli çalışma dizinine göre) veren path-like object ‘dir. (Eğer bir dosya açıklayıcısı veirldiyse, closefd, False ‘a ayarlanmadığı sürece I/O nesnesi kapatıldığında kapatılır.

mode is an optional string that specifies the mode in which the file is opened. It defaults to 'r' which means open for reading in text mode. Other common values are 'w' for writing (truncating the file if it already exists), 'x' for exclusive creation, and 'a' for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform-dependent: locale.getencoding() is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:

Karakter	Anlam
`'r'`	okumaya açık (varsayılan)
`'w'`	yazmaya açık, önce dosyayı keser
`'x'`	ayrıcalıklı oluşturma için açık, dosya varsa hata verir
`'a'`	yazmaya açık, eğer dosya bulunuyorsa dosyaya ekleme yapar
`'b'`	ikili mod
`'t'`	metin modu (varsayılan)
`'+'`	güncellemeye açık (okuma ve yazma)

Varsayılan mod 'r' (okumaya açık, 'rt' ‘nin eşanlamlısı.) ‘dir. 'w+' ve 'w+b' modları dosyayı açar ve temizlerler. 'r+' ve 'r+b' modları dosyayı temizlemeden açarlar.

Overview ‘de bahsedildiği gibi, Python ikili ve metin I/O arasında ayrım yapar. İkili modda (mode parametresinde 'b' ‘yi içererek) açılan dosyalar, içerikleri bytes nesneleri halinde deşifre etmeden döndürür. Metin modunda (varsayılan, veya mode parametresinde 't' içerildiğinde), dosyanın içeriği str olarak döndürülür, baytlar platforma bağlı bir kodlayıcı veya belirtilen encoding ‘i kullanarak deşifre edilir.

Not

Python, temel alınan işletim sisteminin metin dosyaları kavramına bağlı değildir. Tüm işlemler Python’un kendisi tarafından yapılır ve bu yüzden de platformdan bağımsızdır.

buffering, arabelleğe alma ilkesini ayarlamak için kullanılan isteğe bağlı bir tamsayıdır. Arabelleğe almayı kapatmak için 0 (yalnızca ikili modda yazılırken izin verilir), satır arabelleğini seçmek için 1 (yalnızca metin modunda kullanılabilir) ve sabit boyutlu yığın arabelleğinin bayt cinsinden boyutunu belirtmek için birden büyük bir tam sayı iletin. Bir arabellek boyutunu bu şekilde belirtmenin ikili arabelleğe alınmış G/Ç için geçerli olduğunu unutmayın, ancak TextIOWrapper (yani, mode='r+' ile açılan dosyalar) başka bir arabelleğe alır. TextIOWrapper arabelleğe almayı devre dışı bırakmak için, io.TextIOWrapper.reconfigure() için write_through bayrağını kullanmayı düşünün. arabelleğe alma bağımsız değişkeni verilmediğinde, varsayılan arabelleğe alma ilkesi şu şekilde çalışır:

Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s “block size” and falling back on io.DEFAULT_BUFFER_SIZE. On many systems, the buffer will typically be 4096 or 8192 bytes long.
“İnteraktif” metin dosyaları (isatty() ‘nın True döndürdüğü dosyalar) satır arabelleğe almayı kullanır. Diğer metin dosyaları yukarıda ikili dosyalar için açıklanan poliçeyi kullanırlar.

encoding dosyayı kodlamak veya deşifre etmek için kullanılan kodlayıcının ismidir. Bu sadece metin modunda kullanılmalıdır. Varsayılan kodlayıcı platforma bağımlıdır (locale.getpreferredencoding() ne döndürüyorsa), ama Python tarafından desteklenen herhangi bir text encoding kullanılabilir. Desteklenen kodlayıcıların listesi için codecs modülüne bkz.

errors şifreleme ve deşifreleme hatalarının nasıl işleneceğini belirten opsiyonel bir dizedir—bu ikili modda kullanılamaz. Bazı standart hata işleyecileri mevcuttur (Error Handlers ‘da listelendi), ayrıca codecs.register_error() ile kaydedilen herhangi bir hata işleyici ismi de geçerlidir. Standart isimler bunları içerir:

'strict', bir kodlama hatası varsa bir ValueError istisnasını yükseltmek için kullanılır. Varsayılan değer None ile aynı etkiyi gösterir.
'ignore' hataları görmezden gelir. Kodlayıcı hatalarını görmezden gelmenin veri kaybı ile sonuçlanabileceğini unutmayın.
'replace' hatalı biçimlendirilmiş veri olduğunda bir yedek işaretleyici ('?' gibi) ‘nin hatalı biçimlendirilmiş verinin yerine geçmesine neden olur.
'surrogateescape', hatalı baytları U+DC80’den U+DCFF’ye kadar değişen vekil kod birimleri olarak sunacaktır. Bu vekil kod birimleri sonradan surrogateescape hata işleyicisi veri yazmak için kullanıldığında aynı baytlara geri döndürülecektir. Bu dosyaları bilinmeyen bir kodlayıcıyla işlerken kullanışlıdır.
'xmlcharrefreplace' is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference &#nnn;.
'backslashreplace' Python’un ters slash kaçış karakterleri yüzünden oluşan hatalı veriyi değiştirir.
'namereplace' (sadece yazarken desteklenir) desteklenmeyen karakterleri \N{...} kaçış karakterleriyle değiştirir.

newline akıştan yeni satır karakterlerinin nasıl ayrıştırılacağını belirler. None, '', '\n', '\r' ve '\r\n' olabilir. Aşağıdaki gibi çalışır:

Akıştan veri okurken eğer newline None ise, evrensel newlines aktif hale getirilir. Girdideki satırlar '\n', '\r', veya '\r\n' ile bitebilirler ve bunlar çağrıcıya döndürülmeden önce '\n' ‘e çevrilirler. Eğer '' ise, evrensel newlines aktif hale getirilir ama satır sonları çağrıcıya çevrilmeden döndürülürler. Eğer başka bir geçerli değer verildiyse, girdi satırları sadece verilen dize ile sonlanır ve satır sonu çağrıcıya çevrilmeden döndürülür.
Çıktıyı akışa yazarkeni eğer newline None ise, tüm '\n' karakterleri sistemin varsayılan satır ayırıcısına, os.linesep ‘e dönüştürülür. Eğer newline '' veya '\n' ise, bir dönüştürme yapılmaz. Eğer newline diğer uygun değerlerden biri ise, tüm '\n' karakterleri verilen dizeye dönüştürülür.

Eğer closefd, False ise ve dosya adı yerine bir dosya tanımlayıcısı verildiyse, dosya kapatıldığında temel dosya tanımlayıcısı açık kalacaktır. Eğer bir dosya adı verildiyse, closefd True olmalıdır (varsayılan); aksi takdirde, bir hata ortaya çıkar.

opener yerine bir çağrılabilir nesne verilerek özel bir açıcı kullanabilirsiniz. Dosya nesnesi için temel dosya tanımlayıcısı sonradan opener ‘ı (file, flags) ile çağırarak elde edilir. opener bir açık dosya tanımlayıcısı döndürmelidir (opener yerine os.open göndermek fonksiyonel olarak None göndermek ile benzer sonuçlanır).

Yeni oluşturulan dosya non-inheritable ‘dir.

Aşağıdaki örnek verilen bir dizine ait bir dosyayı açmak için os.open() fonksiyonunun dir_fd parametresini kullanır:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

open() metodu tarafından döndürülen file object ‘in tipi moda bağlıdır. open() bir dosyayı metin modunda ('w', 'r', 'wt', 'rt' vb.) açmak için kullanıldığında, io.TextIOBase ‘in bir alt sınıfını döndürür (özellikle io.TextIOWrapper). Bir dosyayı ikili modda arabellek ile açmak için kullanıldığında, döndürülen sınıf io.BufferedIOBase ‘ın alt sınıfıdır. Kesin sınıf değişkendir: ikili okuma modunda, bir io.BufferedReader döndürür; ikili yazma ve ikili ekleme modunda, io.BufferedWriter döndürür, ve okuma/yazma modunda io.BufferedRandom döndürür. Arabelleğe alma devre dışı olduğunda, ham akış, io.RawIOBase ‘in alt sınıfı, io.FileIO döndürülür.

Ayrıca fileinput, io (open() ‘ın tanımlandığı yer), os, os.path, tempfile, ve shutil gibi dosya işleme modüllerine de bkz.

Raises an auditing event open with arguments path, mode, flags.

mode ve flags parametreleri orijinal çağrı tarafından modifiye edilmiş veya çıkartılmış olabilir.

3.3 sürümünde değişti:

opener parametresi eklendi.
'x' modu eklendi.
Eskiden IOError hatası ortaya çıkardı, şimdi OSError ‘un takma adıdır.
Artık eğer özel oluşturma modunda ('x') açılmış dosyalar zaten bulunuyorsa FileExistsError hatası ortaya çıkar.

3.4 sürümünde değişti:

Dosya artık miras alınamaz.

3.5 sürümünde değişti:

Eğer sistem çağrısı bölündüyse ve sinyal işleyicisi bir hata ortaya çıkartmazsa, artık fonksiyon InterruptedError hatası ortaya çıkartmak yerine sistem çağrısını yeniden dener (açıklama için PEP 475 bkz).
'namereplace' hata işleyicisi eklendi.

3.6 sürümünde değişti:

os.PathLike uygulayan nesneleri kabul etme desteği eklendi.
Windows’da, bir konsol arabelleğinin açılması io.FileIO dışında bir io.RawIOBase alt sınıfını döndürebilir.

3.11 sürümünde değişti: 'U' modu kaldırıldı.

ord(c)¶: Bir Unicode karakterini temsil eden dize verilir ve o karakterin Unicode kod noktasını temsil eden bir tamsayı döndürür. Örneğin, ord('a') 97 tamsayısını döndürür ve ord('€') (Euro simgesi) 8364 tamsayısını döndürür. Bu chr() ‘nin tersidir.

pow(base, exp, mod=None)¶

base ‘in exp kuvvetini döndürür; mod verildiyse, aynı sayı % mod sonucunu döndürür (pow(base,exp) % mod ‘dan daha verimli işlenir). İki parametreli formu pow(base, exp), üs operatörü base**exp kullanmaya eş değerdir.

The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, pow(10, 2) returns 100, but pow(10, -2) returns 0.01. For a negative base of type int or float and a non-integral exponent, a complex result is delivered. For example, pow(-9, 0.5) returns a value close to 3j. Whereas, for a negative base of type int or float with an integral exponent, a float result is delivered. For example, pow(-9, 2.0) returns 81.0.

int işlemleri için mod verilmişse, base ve exp bir tam sayı olmalıdır, aynı zamanda mod sıfır olamaz. Eğer mod verilmişse ve exp negatifse, base, mod için görece asal olmalıdır. Bu durumda, pow(inv_base,-exp,mod) döndürülüri inv_base, *base mod mod ‘un tersidir.

Burada 38 mod 97 ‘nin tersini işlemek için bir örnek var:

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

3.8 sürümünde değişti: int işlenenleri için, pow ‘un üç parametreli formu artık ikinci parametrenin negatif olmasına, modüler terslerin hesaplanmasına izin verir.

3.8 sürümünde değişti: Anahtar kelime parametrelerine izin ver, önceden sadece pozisyonel parametreler desteklenirdi.

print(*objects, sep=' ', end='\n', file=None, flush=False)¶

Metin akış file ‘ına sep tarafından ayırılacak ve end ile bitirilecek şekilde objects ‘i yazdırır. sep, end, *file, ve flush sunulursa anahtar kelime parametreleri olarak verilmelidir.

Tüm anahtar kelime olmayan parametler str() ‘in yaptığı gibi dizeye çevirilir ve sep tarafından ayırılıp end ile bitecek şekilde akışa yazdırılır. sep ve end dize veya None olmalıdır. None olduğunda varsayılan değerler kullanılır. Eğer objects verilmediyse, print() sadece end ‘i yazdırır.

file parametresi write(string) metodu içeren bir obje olmalıdır; eğer sunulmamış veya None ise, sys.stdout kullanılacaktır. Yazdırılan argümanlar metin dizelerine çevrildiğinden, print() ikili dosya nesneleri ile kullanılamaz. Bunlar için, file.write(...) ‘ı kullanın.

Output buffering is usually determined by file. However, if flush is true, the stream is forcibly flushed.

3.3 sürümünde değişti: flush anahtar kelimesi argümanı eklendi.

class property(fget=None, fset=None, fdel=None, doc=None)¶

Bir özellik özelliği döndürür.

fget bir özelliğin değerini almak için kullanılan bir fonksiyondur. fset bir özelliğin değerini ayarlamak için kullanılan bir fonksiyondur. fdel bir özelliğin değerini silmek için kullanılan bir fonksiyondur, ve doc özellik için bir belge dizisi oluşturur.

Yönetilen bir x özelliği tanımlamak için tipik bir yöntem:

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

Eğer c, C ‘nin bir örneğiyse, c.x, alıcı fonksiyonu çağıracaktır. c.x = value ayarlayıcı fonksiyonu, del c.x ise siliciyi çağıracaktır.

Eğer verildiyse, doc property özelliğinin doküman dizisi olacaktır. Aksi takdirde, property fget ‘in (bulunuyorsa) doküman dizisini kopyalayacaktır. Bu property() ‘i decorator olarak kullanarak kolayca salt-okunur özellikler oluşturmayı mümkün kılar:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

The @property decorator turns the voltage() method into a “getter” for a read-only attribute with the same name, and it sets the docstring for voltage to “Get the current voltage.”

@getter¶

@setter¶

@deleter¶

A property object has getter, setter, and deleter methods usable as decorators that create a copy of the property with the corresponding accessor function set to the decorated function. This is best explained with an example:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Bu kod birinci örneğin tamamen eş değeridir. Orijinal özellikte olduğu gibi ekstra fonksiyonlara aynı ismi verdiğinizden emin olun (bu durumda x).

Döndürülen property nesnesi yapıcı metotta verilen fget, fset, ve fdel özelliklerine sahiptir.

3.5 sürümünde değişti: Property nesnelerinin doküman dizeleri artık yazılabilir.

__name__¶: Attribute holding the name of the property. The name of the property can be changed at runtime.

Added in version 3.13.

class range(stop)
class range(start, stop, step=1): Bir metot olmaktansa, range aslında bir değiştirilemez dizi tipidir. Daha fazla bilgi için Aralıklar ve Dizi Tipleri — list, tuple, range ‘e bakınız.

repr(object)¶

Return a string containing a printable representation of an object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(); otherwise, the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. A class can control what this function returns for its instances by defining a __repr__() method. If sys.displayhook() is not accessible, this function will raise RuntimeError.

This class has a custom representation that can be evaluated:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"

reversed(seq)¶: Return a reverse iterator. seq must be an object which has a __reversed__() method or supports the sequence protocol (the __len__() method and the __getitem__() method with integer arguments starting at 0).

round(number, ndigits=None)¶

Noktadan sonra ndigits basamak hassasiyetiyle number ‘ı yuvarlar. Eğer ndigits verilmediyse veya None ise, number ‘a en yakın tam sayı döndürülür.

round() ‘u destekleyen yerleşik yapılar için, değerler 10 üssü ndigits ‘in en yakın katına yuvarlanır; eğer iki kat da eşitse, yuvarlama işlemi çift sayıya doğru yapılır (örneğin, round(0.5) ve round(-0.5) ‘in değerleri 0 ‘dır. ve round(1.5), 2 ‘dir). ndigits için herhangi bir tamsayı değeri (pozitif, sıfır veya negatif) uygundur. ndigits verilmediyse veya None ise döndürülen değer bir tam sayıdır. Aksi takdirde, döndürülen değerin tipi number ‘ınkiyle aynıdır.

Genel bir Python nesnesi için number, round number.__round__ ‘u temsil eder.

Not

Gerçel sayılar için round() ‘un davranışı şaşırtıcı olabilir: örneğin round(2.675, 2) beklenen gibi 2.68 yerine 2.67 sonucunu verir. Bu bir hata değil; çoğu ondalıklı kesir tamı tamına bir gerçel sayı olarak gösterilemeyeceğinden bu sonucu alıyoruz. Daha fazla bilgi için Floating-Point Arithmetic: Issues and Limitations ‘e bkz.

class set

class set(iterable)

Opsiyonel olarak iterable ‘dan alınan elementlerle yeni bir set nesnesi döndürür. set yerleşik bir sınıftır. Bu sınıf hakkında dokümantasyon için set ve Set Türleri — set, frozenset ‘e bakınız.

Diğer konteynerler için, yerleşik frozenset, list, tuple ve dict sınıflarını; aynı zamanda collections modülüne bakınız.

setattr(object, name, value)¶

Bu getattr() ‘un karşılığıdır. Argümanlar bir nesne, dize ve opsiyonel değerdir. Dize halihazırda var olan veya yeni bir özelliğe isim verebilir. Fonksiyon, nesnenin izin vermesi koşuluyla, değeri özelliğe atar. Örneğin setattr(x, 'foobar', 123) ve x.foobar = 123 eş değerdir.

name, nesne bunu zorunlu kılmayı seçmedikçe, örneğin özel bir __getattribute__() veya __slots__ aracılığıyla, Identifiers and keywords içinde tanımlandığı gibi bir Python tanımlayıcısı olmak zorunda değildir. Adı tanımlayıcı olmayan bir özelliğe nokta kullanılarak erişilemez, ancak getattr() vb. aracılığıyla erişilebilir.

Not

Özel isim karıştırma, derleme sürecinde olacağından, setattr() ile ayarlamak için özel bir niteliğin (iki alt çizgi ile başlayan nitelikler) adını manuel olarak değiştirmek gerekir.

class slice(stop)¶

class slice(start, stop, step=None)

Return a slice object representing the set of indices specified by range(start, stop, step). The start and step arguments default to None.

start¶

stop¶

step¶: Slice objects have read-only data attributes start, stop, and step which merely return the argument values (or their default). They have no other explicit functionality; however, they are used by NumPy and other third-party packages.

Slice objects are also generated when extended indexing syntax is used. For example: a[start:stop:step] or a[start:stop, i]. See itertools.islice() for an alternate version that returns an iterator.

3.12 sürümünde değişti: Slice objects are now hashable (provided start, stop, and step are hashable).

sorted(iterable, /, *, key=None, reverse=False)¶

iterable ‘ın içindeki elementlerden oluşan sıralı bir liste döndürür.

İsimle belirtilmesi gereken 2 opsiyonel parametresi vardır.

key, iterable ‘ın her elementinden bir karşılaştırma anahtarı ayıklamak için kullanılan bir argümanın fonksiyonunu belirtir (örneğin, key=str.lower). Varsayılan değer None ‘dır (elementleri direkt karşılaştırır).

reverse bir boolean değerdir. Eğer True ise, liste elementleri tüm karşılaştırmalar tersine çevrilmiş şekilde sıralanır.

Eski stil cmp fonksiyonunu bir key fonksiyonuna dönüştürmek için functools.cmp_to_key() ‘yi kullanın.

Yerleşik sorted() fonksiyonunun stabil çalışması garantilenmiştir. Bir sıralama eşit olan elementlerin ilgili sırasını değiştirmemeyi garantiliyorsa stabildir — bu çoklu geçişlerle sıralama (örneğin önce departman, ardından maaş sıralama) için yardımcıdır.

Sıralama algoritması elementler arasında sadece < karşılaştırmalarını kullanır. Bir __lt__() metodu tanımlamak sıralamak için yeterli olmasına rağmen, PEP 8 tüm altı rich comparisons ‘ların uygulanmasını öneriyor. Bu aynı veri ile max() gibi farklı bir temel metot ile çalışan farklı sıralama araçlarını kullanırken hataları önlemeyi kolaylaştıracaktır. Tüm karşılaştırmaları uygulamak ayrıca yansıtılan __gt__() metodunu çağırabilen karmaşık tür karşılaştırmaları için karışıklığı da önler.

Sıralama örnekleri ve kısa sıralama öğreticisi için Sorting Techniques ‘ya bakınız.

@staticmethod¶

Bir metodu statik metoda dönüştürür.

Statik bir metot üstü kapalı şekilde bir ilk argüman almaz. Statik metot tanımlamak için bu ifadeyi kullanabilirsiniz:

class C:
    @staticmethod
    def f(arg1, arg2, argN): ...

@staticmethod ifadesi bir decorator fonksiyonudur. – detaylar için Function definitions bkz.

A static method can be called either on the class (such as C.f()) or on an instance (such as C().f()). Moreover, the static method descriptor is also callable, so it can be used in the class definition (such as f()).

Python’daki statik metotlar Java ve C++’takilerle benzerdir. Ayrıca, sınıf için alternatif bir yapıcı metot oluşturmak isterseniz classmethod() bkz.

Tüm dekoratörler gibi, staticmethod ‘u normal bir fonksiyon gibi çağırmak ve sonucu ile bir şeyler yapmak mümkündür. Bu, bir sınıfın fonksiyonuna referans vermeniz gerektiğinde ve örnek metoda otomatik dönüşümü engellemek istediğinizde işinize yarayabilir. Böyle durumlar için, bu ifadeyi kullanabilirsiniz:

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Statik metotlar hakkında daha fazla bilgi için, The standard type hierarchy bkz.

3.10 sürümünde değişti: Static methods now inherit the method attributes (__module__, __name__, __qualname__, __doc__ and __annotations__), have a new __wrapped__ attribute, and are now callable as regular functions.

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

object ‘in str versiyonunu döndürür. Detaylar için str() bkz.

str yerleşik dize class ‘ıdır. Dizeler hakkında genel bilgi için, Metin Sırası Türü — str bkz.

sum(iterable, /, start=0)¶

start ve iterable ‘ın elemanlarını soldan sağa toplar ve toplamı döndürür. iterable ‘ın elemanları normal olarak numaralardır ve başlangıç değeri bir dize olamaz.

For some use cases, there are good alternatives to sum(). The preferred, fast way to concatenate a sequence of strings is by calling ''.join(sequence). To add floating-point values with extended precision, see math.fsum(). To concatenate a series of iterables, consider using itertools.chain().

3.8 sürümünde değişti: start parametresi bir anahtar kelime argümanı olarak belirtilebilir.

3.12 sürümünde değişti: Summation of floats switched to an algorithm that gives higher accuracy and better commutativity on most builds.

class super¶

class super(type, object_or_type=None)

type ‘ın ebeveyn veya kardeş sınıfına yapılan metot çağrılarını temsil eden bir proxy objesi döndürür. Bu bir sınıfta üzerine yazılmış kalıtılan metotlara erişmek için kullanışlıdır.

object_or_type aranacak method resolution order ‘nı belirler. Arama type ‘dan sonraki ilk sınıftan başlar.

For example, if __mro__ of object_or_type is D -> B -> C -> A -> object and the value of type is B, then super() searches C -> A -> object.

The __mro__ attribute of the class corresponding to object_or_type lists the method resolution search order used by both getattr() and super(). The attribute is dynamic and can change whenever the inheritance hierarchy is updated.

Eğer ikinci parametre atlanırsa, döndürülen süper objesi serbesttir. Eğer ikinci parametre bir objeyse, isinstance(obj, type) doğru olmak zorundadır. Eğer ikinci parametre bir tür ise, issubclass(type2, type) doğru olmak zorundadır (bu sınıf metotları için kullanışlıdır).

When called directly within an ordinary method of a class, both arguments may be omitted (“zero-argument super()”). In this case, type will be the enclosing class, and obj will be the first argument of the immediately enclosing function (typically self). (This means that zero-argument super() will not work as expected within nested functions, including generator expressions, which implicitly create nested functions.)

super için tipik iki kullanım şekli vardır. Tek kalıtımlı bir sınıf hiyerarşisinde super üst sınıfları açıkça adlandırmadan onlara başvurmak için kullanılabilir. böylece kodu daha sürdürülebilir hale getirir.

İkinci kullanım şekli dinamik yürütme ortamında işbirlikli çoklu kalıtımı desteklemektir. Bu durum Python’a özgüdür ve statik derlenen diller veya tekli kalıtımı destekleyen dillerde bulunmaz. Bu çoklu temel sınıfların aynı metodu uyguladığı “diamond diagrams” sistemini uygulamayı mümkün kılar. İyi tasarım bu tür uygulamaların her durumda aynı çağrı imzasına sahip olduğunu (çünkü çağrıların sırası yürütme zamanında belirlenir, çünkü bu sıra sınıf hiyerarşisindeki değişikliklere uyarlanır ve çalışma zamanından önce bilinmeyen kardeş sınıfları içerebilir) dikte eder.

İki kullanım durumu için de, tipik bir üst sınıf çağrısı bu şekildedir:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

Metot aramalarına ek olarak, super() özellik aramaları için de çalışır. Bunun kullanım şekli ebeveyn veya kardeş bir sınıfta tanımlayıcılar ‘i çağırmaktır.

Note that super() is implemented as part of the binding process for explicit dotted attribute lookups such as super().__getitem__(name). It does so by implementing its own __getattribute__() method for searching classes in a predictable order that supports cooperative multiple inheritance. Accordingly, super() is undefined for implicit lookups using statements or operators such as super()[name].

Ayrıca, argümansız formunun yanı sıra, süper() iç metotları kullanmakla sınırlı değildir. İki parametreli form parametlerini tamı tamına belirler ve uygun karşılaştırmaları yapar. Argümansız form sadece bir sınıf tanımının içinde çalışır, derleyici tanımlanan sınıfı doğru şekilde almak ve sıradan yöntemlere geçerli örnekten erişmek için gerekli detayları doldurur.

super() ‘ı kullanarak kooperatif sınıflar tasarlamaya yönelik pratik öneriler için, guide to using super() bkz.

class tuple
class tuple(iterable): Bir fonksiyon olmaktansa, tuple Demetler ve Dizi Tipleri — list, tuple, range ‘de gösterildiği gibi düzenlenemez bir dizi türüdür.

class type(object)¶

class type(name, bases, dict, **kwds)

With one argument, return the type of an object. The return value is a type object and generally the same object as returned by object.__class__.

isinstance() yerleşik fonksiyonu bir objenin türünü test etmek için önerilir. Çünkü altsınıfları hesaba katar.

With three arguments, return a new type object. This is essentially a dynamic form of the class statement. The name string is the class name and becomes the __name__ attribute. The bases tuple contains the base classes and becomes the __bases__ attribute; if empty, object, the ultimate base of all classes, is added. The dict dictionary contains attribute and method definitions for the class body; it may be copied or wrapped before becoming the __dict__ attribute. The following two statements create identical type objects:

>>> class X:
...     a = 1
...
>>> X = type('X', (), dict(a=1))

Gömülü Fonksiyonlar¶

İçindekiler

Önceki konu

Sonraki konu

Bu Sayfa