Define names for built-in types tha

Define names for built-in types that aren't directly accessible as a builtin.
"""
import sys

# Iterators in Python aren't a matter of type but of protocol. A large
# and changing number of builtin types implement *some* flavor of
# iterator. Don't check the type! Use hasattr to check for both
# "__iter__" and "__next__" attributes instead.

def _f(): pass
FunctionType = type(_f)
LambdaType = type(lambda: None) # Same as FunctionType
CodeType = type(_f.__code__)
MappingProxyType = type(type.__dict__)
SimpleNamespace = type(sys.implementation)

def _g():
yield 1
GeneratorType = type(_g())

class _C:
def _m(self): pass
MethodType = type(_C()._m)

BuiltinFunctionType = type(len)
BuiltinMethodType = type([].append) # Same as BuiltinFunctionType

ModuleType = type(sys)

try:
raise TypeError
except TypeError:
tb = sys.exc_info()[2]
TracebackType = type(tb)
FrameType = type(tb.tb_frame)
tb = None; del tb

# For Jython, the following two types are identical
GetSetDescriptorType = type(FunctionType.__code__)
MemberDescriptorType = type(FunctionType.__globals__)

del sys, _f, _g, _C, # Not for export


# Provide a PEP 3115 compliant mechanism for class creation
def new_class(name, bases=(), kwds=None, exec_body=None):
"""Create a class object dynamically using the appropriate metaclass."""
meta, ns, kwds = prepare_class(name, bases, kwds)
if exec_body is not None:
exec_body(ns)
return meta(name, bases, ns, **kwds)

def prepare_class(name, bases=(), kwds=None):
"""Call the __prepare__ method of the appropriate metaclass.

Returns (metaclass, namespace, kwds) as a 3-tuple

*metaclass* is the appropriate metaclass
*namespace* is the prepared class namespace
*kwds* is an updated copy of the passed in kwds argument with any
'metaclass' entry removed. If no kwds argument is passed in, this will
be an empty dict.
"""
if kwds is None:
kwds = {}
else:
kwds = dict(kwds) # Don't alter the provided mapping
if 'metaclass' in kwds:
meta = kwds.pop('metaclass')
else:
if bases:
meta = type(bases[0])
else:
meta = type
if isinstance(meta, type):
# when meta is a type, we first determine the most-derived metaclass
# instead of invoking the initial candidate directly
meta = _calculate_meta(meta, bases)
if hasattr(meta, '__prepare__'):
ns = meta.__prepare__(name, bases, **kwds)
else:
ns = {}
return meta, ns, kwds

def _calculate_meta(meta, bases):
"""Calculate the most derived metaclass."""
winner = meta
for base in bases:
base_meta = type(base)
if issubclass(winner, base_meta):
continue
if issubclass(base_meta, winner):
winner = base_meta
continue
# else:
raise TypeError("metaclass conflict: "
"the metaclass of a derived class "
"must be a (non-strict) subclass "
"of the metaclasses of all its bases")
return winner

class DynamicClassAttribute:
"""Route attribute access on a class to __getattr__.

This is a descriptor, used to define attributes that act differently when
accessed through an instance and through a class. Instance access remains
normal, but access to an attribute through a class will be routed to the
class's __getattr__ method; this is done by raising AttributeError.

This allows one to have properties active on an instance, and have virtual
attributes on the class with the same name (see Enum for an example).

"""
def __init__(self, fget=None, fset=None, fdel=None, doc=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
# next two lines make DynamicClassAttribute act the same as property
self.__doc__ = doc or fget.__doc__
self.overwrite_doc = doc is None
# support for abstract methods
self.__isabstractmethod__ = bool(getattr(fget, '__isabstractmethod__', False))

def __get__(self, instance, ownerclass=None):
if instance is None:
if self.__isabstractmethod__:
return self
raise AttributeError()
elif self.fget is None:
raise AttributeError("unreadable attribute")
return self.fget(instance)

def __set__(self, instance, value):
if self.fset is None:
raise AttributeError("can't set attribute")
self.fset(instance, value)

def __delete__(self, instance):
if self.fdel is None:
raise AttributeError("can't delete attribute")
self.fdel(instance)

def getter(self, fget):
fdoc = fget.__doc__ if self.overwrite_doc

Kết quả (Việt) 1:

Xác định tên cho xây dựng trong các loại mà không phải là trực tiếp có thể truy cập một builtin."""nhập khẩu sys# Vòng lặp trong Python không phải là một vấn đề của kiểu nhưng giao thức. Một lượng lớn# và thay đổi số lượng builtin loại thực hiện * một * hương vị của# iterator. Không kiểm tra các loại! Sử dụng hasattr để kiểm tra cho cả hai# "__iter__" và "__next__" thuộc tính để thay thế.def _f(): vượt quaFunctionType = type(_f)LambdaType = type(lambda: None) # tương tự như FunctionTypeCodeType = type(_f.__code__)MappingProxyType = type(type.__dict__)SimpleNamespace = type(sys.implementation)def _g(): sản lượng 1GeneratorType = type(_g())lớp _C: def _m(self): vượt quaMethodType = type(_C()._m)BuiltinFunctionType = type(len)BuiltinMethodType = type([].append) # tương tự như BuiltinFunctionTypeModuleType = type(sys)Hãy thử: nâng cao TypeErrorNgoại trừ TypeError: TB = sys.exc_info() [2] TracebackType = type(tb) FrameType = type(tb.tb_frame) TB = không có gì; del tb# Cho Jython, hai loại sau là giống hệt nhauGetSetDescriptorType = type(FunctionType.__code__)MemberDescriptorType = type(FunctionType.__globals__)del sys, _f, _g, _C, # không cho xuất khẩu# Cung cấp một cơ chế phù hợp PEP 3115 cho lớp học sáng tạodef new_class (tên, bases=(), kwds = không có gì, exec_body = không có gì): "" "Tạo ra một lớp đối tượng tự động bằng cách sử dụng các metaclass thích hợp." "" Meta, ns, kwds = prepare_class (tên, căn cứ, kwds) Nếu exec_body không phải là không có: exec_body(NS) trở về meta (tên, căn cứ, ns, ** kwds)def prepare_class (tên, bases=(), kwds = không có gì): "" "Gọi phương thức __prepare__ của metaclass thích hợp. Trở về (metaclass, không gian tên, kwds) như là 3 tuple metaclass * là thích hợp metaclass không gian tên * là không gian tên lớp học chuẩn bị kwds * là một bản Cập Nhật của việc thông qua trong kwds đối với bất kỳ 'metaclass' mục gỡ bỏ. Nếu không có đối số kwds được thông qua vào, điều này sẽ là một sản phẩm nào dict. """ Nếu không phải là kwds: kwds = {} khác: kwds = dict(kwds) # không làm thay đổi bản đồ được cung cấp Nếu 'metaclass' trong kwds: Meta = kwds.pop('metaclass') khác: Nếu căn cứ: Meta = type(bases[0]) khác: Meta = loại Nếu isinstance (meta, loại): # Khi meta là một loại, chúng tôi lần đầu tiên xác định hầu hết nguồn gốc metaclass # thay vì gọi các ứng cử viên ban đầu trực tiếp Meta = _calculate_meta (meta, căn cứ) Nếu hasattr (meta, '__prepare__'): NS = meta.__prepare__ (tên, căn cứ, ** kwds) khác: NS = {} trở về meta, ns, kwdsdef _calculate_meta (meta, cơ sở): "" "Tính toán nhất có nguồn gốc metaclass." "" người chiến thắng = meta Đối với cơ sở ở cơ sở: base_meta = type(base) Nếu issubclass (người chiến thắng, base_meta): tiếp tục Nếu issubclass (base_meta, người chiến thắng): người chiến thắng = base_meta tiếp tục # khác: nâng cao TypeError ("xung đột metaclass:" "các metaclass của một lớp học có nguồn gốc" "phải có một phân lớp (không nghiêm ngặt)" "của các metaclasses tất cả các căn cứ của nó") trở lại chiến thắnglớp học DynamicClassAttribute: "" "Tuyến đường thuộc tính truy cập vào một lớp học để __getattr__. Đây là một mô tả, được sử dụng để xác định các thuộc tính hành động một cách khác nhau khi truy cập thông qua một thể hiện và thông qua một lớp học. Ví dụ truy cập vẫn còn bình thường, nhưng truy cập vào một thuộc tính thông qua một lớp học sẽ được chuyển đến các Các phương pháp __getattr__ của lớp; Điều này được thực hiện bằng cách tăng AttributeError. Điều này cho phép một để có tài sản hoạt động trên một trường hợp, và có ảo Các thuộc tính trên lớp có cùng tên (xem Enum ví dụ). """ def __init__ (tự, fget = không có gì, fset = không có gì, fdel = không có gì, doc = không có gì): self.fget = fget self.fset = fset self.fdel = fdel # tiếp theo hai đường làm cho DynamicClassAttribute hành động giống như bất động sản self.__doc__ = doc hoặc fget.__doc__ self.overwrite_doc = doc là không có # hỗ trợ cho phương pháp trừu tượng self.__isabstractmethod__ = bool (getattr (fget, '__isabstractmethod__', False)) def __get__ (tự, ví dụ, ownerclass = không có gì): Nếu không phải là trường hợp: Nếu self.__isabstractmethod__: trở lại tự nâng cao AttributeError() Elif self.fget là không có: nâng cao AttributeError ("thuộc tính không thể đọc được") trở lại self.fget(instance) def __set__ (tự, ví dụ, giá trị): Nếu không phải là self.fset: nâng cao AttributeError ("không thể đặt thuộc tính") self.fset (ví dụ, giá trị) def __delete__ (tự, ví dụ): Nếu không phải là self.fdel: nâng cao AttributeError ("không thể xóa thuộc tính") self.fdel(instance) def getter (tự, fget): fdoc = fget.__doc__ nếu self.overwrite_doc

Kết quả (Việt) 2:

Xác định tên cho xây dựng trong các loại mà không phải truy cập trực tiếp như một dựng sẵn.
"" "
Import sys

# Vòng lặp trong Python không phải là một vấn đề của loại nhưng các giao thức. Một lượng lớn
# và thay đổi số lượng các loại dựng sẵn thực hiện * một số * hương vị của
.! # iterator không kiểm tra các loại Sử dụng hasattr để kiểm tra cho cả
# "__iter__" và "__next__" thuộc tính để thay thế.

def _f (): pass
FunctionType = loại (_f)
LambdaType = loại (lambda: None) # Tương tự như FunctionType
CodeType = loại (_f .__ code__)
MappingProxyType = loại (loại .__ dict__)
SimpleNamespace = loại (sys.implementation)

def _G ():
năng suất 1
GeneratorType = loại (_G ())

lớp _C:
def _M (tự) : vượt qua
MethodType = loại (_C () ._ m)

BuiltinFunctionType = loại (len)
BuiltinMethodType = loại ([] thêm.) # Tương tự như BuiltinFunctionType

ModuleType = loại (sys)

thử:
nâng TypeError
trừ Lỗi loại:
tb = sys.exc_info ( ) [2]
TracebackType = loại (tb)
FrameType = loại (tb.tb_frame)
tb = None; del tb

# Đối với Jython, hai loại sau đây là giống hệt nhau
GetSetDescriptorType = loại (FunctionType .__ code__)
MemberDescriptorType = loại (FunctionType .__ globals__)

del sys, _f, _G, _C, # Không cho xuất khẩu


# Cung cấp PEP 3115 cơ chế phù hợp để tạo lớp
def new_class (tên, căn cứ = (), kwds = None, exec_body = None):
"" "Tạo một đối tượng lớp động sử dụng các metaclass thích hợp "" ".
meta, ns, kwds = prepare_class (tên, căn cứ, kwds)
nếu exec_body không phải là không:
exec_body (ns)
trở meta (tên, bazơ, ns, ** kwds)

def prepare_class (tên, căn cứ = (), kwds = None):
"." "Gọi phương thức __prepare__ của metaclass thích hợp

Returns (metaclass, không gian tên, kwds) như là một 3-tuple

* metaclass * là metaclass thích hợp
* namespace * là không gian tên lớp chuẩn bị
* kwds * là một bản cập nhật của thông qua tại kwds tranh cãi với bất kỳ
mục 'metaclass' loại bỏ. Nếu không có đối số kwds được thông qua tại, điều này sẽ
là một dict trống rỗng.
"" "
Nếu kwds là Không:
kwds = {}
else:
kwds = dict (kwds) # Không làm thay đổi các bản đồ được cung cấp
nếu 'metaclass' trong kwds:
meta = kwds.pop ( 'metaclass')
khác:
nếu căn cứ:
meta = loại (cơ sở [0])
khác:
meta = loại
nếu isinstance (meta, type):
# khi meta là một loại, trước tiên chúng ta xác định most- bắt nguồn metaclass
# thay vì cách gọi các ứng cử viên ban đầu trực tiếp
meta = _calculate_meta (meta, căn cứ)
nếu hasattr (meta, '__prepare__'):
ns = meta .__ chuẩn bị __ (tên, căn cứ, ** kwds)
khác:
ns = {}
trở meta , ns, kwds

def _calculate_meta (meta, căn cứ):
"" "Tính metaclass nguồn gốc nhất." ""
người chiến thắng = meta
cho các cơ sở trong các căn cứ:
base_meta = loại (cơ sở)
nếu issubclass (người chiến thắng, base_meta):
tiếp tục
nếu issubclass ( base_meta, người chiến thắng):
người chiến thắng = base_meta
tiếp tục
# khác:
nâng TypeError ( "metaclass mâu thuẫn:"
"các metaclass của một lớp dẫn xuất"
"phải là một (không đúng) lớp con"
"của metaclasses của tất cả các căn cứ của nó")
trở lại người chiến thắng

lớp DynamicClassAttribute:
. "" "thuộc tính đường truy cập vào một lớp học để __getattr__

Đây là một mô tả, được sử dụng để xác định thuộc tính hành động khác khi
truy cập thông qua một thể hiện và thông qua một lớp học. Truy cập dụ vẫn
bình thường, nhưng truy cập vào một thuộc tính thông qua một lớp sẽ được chuyển đến các
phương pháp __getattr__ của lớp; này được thực hiện bằng cách nâng AttributeError.

Điều này cho phép một người có đặc tính hoạt động trên một ví dụ, và có ảo
thuộc tính trên lớp có cùng tên (xem Enum cho một ví dụ).

"" "
def __init __ (self, fget = None, fset = None, fdel = None, doc = None):
self.fget = fget
self.fset = fset
self.fdel = fdel
# hai dòng tiếp theo làm cho DynamicClassAttribute hành động giống như bất động sản
tự .__ doc__ = doc hoặc fget .__ doc__
self.overwrite_doc = doc là Không
# hỗ trợ cho các phương pháp trừu tượng
tự .__ isabstractmethod__ = bool (getattr (fget, '__isabstractmethod__', False))

def __get __ (bản thân, ví dụ, ownerclass = None):
nếu dụ là Không:
nếu tự .__ isabstractmethod__:
trả lại tự
nâng AttributeError ()
elif self.fget là không:
tăng AttributeError ( "thuộc tính không thể đọc")
trở self.fget (chẳng hạn)

def __set __ (bản thân, ví dụ, giá trị):
nếu self.fset là không:
tăng AttributeError ( "không thể thiết lập thuộc tính ")
self.fset (ví dụ, giá trị)

def __delete __ (bản thân, chẳng hạn):
nếu self.fdel là không:
tăng AttributeError (" không thể xóa thuộc tính ")
self.fdel (chẳng hạn)

def getter (tự, fget ):
fdoc = fget .__ doc__ nếu self.overwrite_doc