An OverflowError is raised if the integer is not representable with the given number of bytes. The byteorder argument determines the byte order used to represent the integer. If byteorder is "big" , the most significant byte is at the beginning of the byte array. If byteorder is "little" , the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys. byteorder as the byte order value.

If signed is False and a negative integer is given, an OverflowError is raised. The default value for signed is False. The argument bytes must either be a bytes-like object or an iterable producing bytes. Return a pair of integers whose ratio is exactly equal to the original integer and with a positive denominator.

The integer ratio of integers whole numbers is always the integer as the numerator and 1 as the denominator. The float type implements the numbers. Real abstract base class. float also has the following additional methods.

Return a pair of integers whose ratio is exactly equal to the original float and with a positive denominator. Raises OverflowError on infinities and a ValueError on NaNs. Return True if the float instance is finite with integral value, and False otherwise:. Two methods support conversion to and from hexadecimal strings. In contrast, hexadecimal strings allow exact representation and specification of floating-point numbers.

This can be useful when debugging, and in numerical work. Return a representation of a floating-point number as a hexadecimal string. For finite floating-point numbers, this representation will always include a leading 0x and a trailing p and exponent.

Class method to return the float represented by a hexadecimal string s. The string s may have leading and trailing whitespace. Note that float. hex is an instance method, while float. fromhex is a class method. Case is not significant, and there must be at least one hexadecimal digit in either the integer or the fraction.

This syntax is similar to the syntax specified in section 6. In particular, the output of float. toHexString are accepted by float. Note that the exponent is written in decimal rather than hexadecimal, and that it gives the power of 2 by which to multiply the coefficient.

For example, the hexadecimal string 0x3. Applying the reverse conversion to For ease of implementation and efficiency across a variety of numeric types including int , float , decimal. Decimal and fractions. Fraction , and all finite instances of float and decimal. Essentially, this function is given by reduction modulo P for a fixed prime P. The value of P is made available to Python as the modulus attribute of sys. If the resulting hash is -1 , replace it with The particular values sys.

inf and -sys. inf are used as hash values for positive infinity or negative infinity respectively. For a complex number z , the hash values of the real and imaginary parts are combined by computing hash z. width - 1. Python supports a concept of iteration over containers. This is implemented using two distinct methods; these are used to allow user-defined classes to support iteration.

Sequences, described below in more detail, always support the iteration methods. One method needs to be defined for container objects to provide iterable support:. Return an iterator object. The object is required to support the iterator protocol described below. If a container supports different types of iteration, additional methods can be provided to specifically request iterators for those iteration types.

An example of an object supporting multiple forms of iteration would be a tree structure which supports both breadth-first and depth-first traversal. The iterator objects themselves are required to support the following two methods, which together form the iterator protocol :. Return the iterator object itself. This is required to allow both containers and iterators to be used with the for and in statements. Return the next item from the iterator.

If there are no further items, raise the StopIteration exception. Python defines several iterator objects to support iteration over general and specific sequence types, dictionaries, and other more specialized forms. The specific types are not important beyond their implementation of the iterator protocol.

Implementations that do not obey this property are deemed broken. More information about generators can be found in the documentation for the yield expression. There are three basic sequence types: lists, tuples, and range objects. Additional sequence types tailored for processing of binary data and text strings are described in dedicated sections. The operations in the following table are supported by most sequence types, both mutable and immutable.

The collections. Sequence ABC is provided to make it easier to correctly implement these operations on custom sequence types. This table lists the sequence operations sorted in ascending priority.

In the table, s and t are sequences of the same type, n , i , j and k are integers and x is an arbitrary object that meets any type and value restrictions imposed by s.

The in and not in operations have the same priorities as the comparison operations. True if an item of s is equal to x , else False. x not in s. False if an item of s is equal to x , else True. index x[, i[, j]]. index of the first occurrence of x in s at or after index i and before index j. Sequences of the same type also support comparisons. In particular, tuples and lists are compared lexicographically by comparing corresponding elements.

This means that to compare equal, every element must compare equal and the two sequences must be of the same type and have the same length. For full details see Comparisons in the language reference. Forward and reversed iterators over mutable sequences access values using an index. That index will continue to march forward or backward even if the underlying sequence is mutated. The iterator terminates only when an IndexError or a StopIteration is encountered or when the index drops below zero.

While the in and not in operations are used only for simple containment testing in the general case, some specialised sequences such as str , bytes and bytearray also use them for subsequence testing:.

Values of n less than 0 are treated as 0 which yields an empty sequence of the same type as s. Note that items in the sequence s are not copied; they are referenced multiple times. This often haunts new Python programmers; consider:. Modifying any of the elements of lists modifies this single list. You can create a list of different lists this way:.

Further explanation is available in the FAQ entry How do I create a multidimensional list? But note that -0 is still 0. If i or j is greater than len s , use len s. If i is omitted or None , use 0. If j is omitted or None , use len s. If i is greater than or equal to j , the slice is empty. When k is positive, i and j are reduced to len s if they are greater. When k is negative, i and j are reduced to len s - 1 if they are greater. Note, k cannot be zero. If k is None , it is treated like 1.

Concatenating immutable sequences always results in a new object. This means that building up a sequence by repeated concatenation will have a quadratic runtime cost in the total sequence length. To get a linear runtime cost, you must switch to one of the alternatives below:. if concatenating str objects, you can build a list and use str.

join at the end or else write to an io. StringIO instance and retrieve its value when complete. if concatenating bytes objects, you can similarly use bytes. join or io. BytesIO , or you can do in-place concatenation with a bytearray object. bytearray objects are mutable and have an efficient overallocation mechanism.

if concatenating tuple objects, extend a list instead. index raises ValueError when x is not found in s. Not all implementations support passing the additional arguments i and j.

These arguments allow efficient searching of subsections of the sequence. Passing the extra arguments is roughly equivalent to using s[i:j]. index x , only without copying any data and with the returned index being relative to the start of the sequence rather than the start of the slice. The only operation that immutable sequence types generally implement that is not also implemented by mutable sequence types is support for the hash built-in. This support allows immutable sequences, such as tuple instances, to be used as dict keys and stored in set and frozenset instances.

Attempting to hash an immutable sequence that contains unhashable values will result in TypeError. The operations in the following table are defined on mutable sequence types. MutableSequence ABC is provided to make it easier to correctly implement these operations on custom sequence types. slice of s from i to j is replaced by the contents of the iterable t. del s[i:j]. the elements of s[i:j:k] are replaced by those of t. del s[i:j:k]. removes the elements of s[i:j:k] from the list.

removes all items from s same as del s[:]. creates a shallow copy of s same as s[:]. insert i, x. pop or s. pop i. remove the first item from s where s[i] is equal to x. The optional argument i defaults to -1 , so that by default the last item is removed and returned.

remove raises ValueError when x is not found in s. The reverse method modifies the sequence in place for economy of space when reversing a large sequence. To remind users that it operates by side effect, it does not return the reversed sequence.

copy is not part of the collections. MutableSequence ABC, but most concrete mutable sequence classes provide it. New in version 3. Zero and negative values of n clear the sequence. Lists are mutable sequences, typically used to store collections of homogeneous items where the precise degree of similarity will vary by application.

Using a pair of square brackets to denote the empty list: []. Using square brackets, separating items with commas: [a] , [a, b, c]. Using a list comprehension: [x for x in iterable]. Using the type constructor: list or list iterable. iterable may be either a sequence, a container that supports iteration, or an iterator object. If iterable is already a list, a copy is made and returned, similar to iterable[:]. For example, list 'abc' returns ['a', 'b', 'c'] and list 1, 2, 3 returns [1, 2, 3].

If no argument is given, the constructor creates a new empty list, []. Many other operations also produce lists, including the sorted built-in. Lists implement all of the common and mutable sequence operations.

Lists also provide the following additional method:. Exceptions are not suppressed - if any comparison operations fail, the entire sort operation will fail and the list will likely be left in a partially modified state. sort accepts two arguments that can only be passed by keyword keyword-only arguments :. The key corresponding to each item in the list is calculated once and then used for the entire sorting process.

The default value of None means that list items are sorted directly without calculating a separate key value. The functools. x style cmp function to a key function. reverse is a boolean value. If set to True , then the list elements are sorted as if each comparison were reversed. This method modifies the sequence in place for economy of space when sorting a large sequence.

To remind users that it operates by side effect, it does not return the sorted sequence use sorted to explicitly request a new sorted list instance.

The sort method is guaranteed to be stable. A sort is stable if it guarantees not to change the relative order of elements that compare equal — this is helpful for sorting in multiple passes for example, sort by department, then by salary grade. For sorting examples and a brief sorting tutorial, see Sorting HOW TO. CPython implementation detail: While a list is being sorted, the effect of attempting to mutate, or even inspect, the list is undefined. The C implementation of Python makes the list appear empty for the duration, and raises ValueError if it can detect that the list has been mutated during a sort.

Tuples are immutable sequences, typically used to store collections of heterogeneous data such as the 2-tuples produced by the enumerate built-in. Tuples are also used for cases where an immutable sequence of homogeneous data is needed such as allowing storage in a set or dict instance. Using a pair of parentheses to denote the empty tuple:.

Using a trailing comma for a singleton tuple: a, or a,. Separating items with commas: a, b, c or a, b, c. Using the tuple built-in: tuple or tuple iterable. If iterable is already a tuple, it is returned unchanged. For example, tuple 'abc' returns 'a', 'b', 'c' and tuple [1, 2, 3] returns 1, 2, 3.

If no argument is given, the constructor creates a new empty tuple,. Note that it is actually the comma which makes a tuple, not the parentheses. The parentheses are optional, except in the empty tuple case, or when they are needed to avoid syntactic ambiguity.

For example, f a, b, c is a function call with three arguments, while f a, b, c is a function call with a 3-tuple as the sole argument. Tuples implement all of the common sequence operations.

For heterogeneous collections of data where access by name is clearer than access by index, collections. namedtuple may be a more appropriate choice than a simple tuple object. The range type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in for loops.

If the step argument is omitted, it defaults to 1. If the start argument is omitted, it defaults to 0. If step is zero, ValueError is raised. A range object will be empty if r[0] does not meet the value constraint. Ranges do support negative indices, but these are interpreted as indexing from the end of the sequence determined by the positive indices.

Ranges containing absolute values larger than sys. maxsize are permitted but some features such as len may raise OverflowError. Ranges implement all of the common sequence operations except concatenation and repetition due to the fact that range objects can only represent sequences that follow a strict pattern and repetition and concatenation will usually violate that pattern.

The value of the start parameter or 0 if the parameter was not supplied. The value of the step parameter or 1 if the parameter was not supplied. The advantage of the range type over a regular list or tuple is that a range object will always take the same small amount of memory, no matter the size of the range it represents as it only stores the start , stop and step values, calculating individual items and subranges as needed.

Range objects implement the collections. Sequence ABC, and provide features such as containment tests, element index lookup, slicing and support for negative indices see Sequence Types — list, tuple, range :.

That is, two range objects are considered equal if they represent the same sequence of values. Changed in version 3. Support slicing and negative indices. Test int objects for membership in constant time instead of iterating through all items.

The linspace recipe shows how to implement a lazy version of range suitable for floating point applications. Textual data in Python is handled with str objects, or strings.

Strings are immutable sequences of Unicode code points. String literals are written in a variety of ways:. Single quotes: 'allows embedded "double" quotes'. Double quotes: "allows embedded 'single' quotes".

Triple quoted: '''Three single quotes''' , """Three double quotes""". Triple quoted strings may span multiple lines - all associated whitespace will be included in the string literal. String literals that are part of a single expression and have only whitespace between them will be implicitly converted to a single string literal. Strings may also be created from other objects using the str constructor. There is also no mutable string type, but str.

StringIO can be used to efficiently construct strings from multiple fragments. It has no effect on the meaning of string literals and cannot be combined with the r prefix. Return a string version of object. If object is not provided, returns the empty string.

Otherwise, the behavior of str depends on whether encoding or errors is given, as follows. If neither encoding nor errors is given, str object returns type object.

For string objects, this is the string itself. If at least one of encoding or errors is given, object should be a bytes-like object e. bytes or bytearray. In this case, if object is a bytes or bytearray object, then str bytes, encoding, errors is equivalent to bytes. decode encoding, errors. Otherwise, the bytes object underlying the buffer object is obtained before calling bytes.

See Binary Sequence Types — bytes, bytearray, memoryview and Buffer Protocol for information on buffer objects. Passing a bytes object to str without the encoding or errors arguments falls under the first case of returning the informal string representation see also the -b command-line option to Python. For example:. For more information on the str class and its methods, see Text Sequence Type — str and the String Methods section below. To output formatted strings, see the Formatted string literals and Format String Syntax sections.

In addition, see the Text Processing Services section. Strings implement all of the common sequence operations, along with the additional methods described below. Strings also support two styles of string formatting, one providing a large degree of flexibility and customization see str. format , Format String Syntax and Custom String Formatting and the other based on C printf style formatting that handles a narrower range of types and is slightly harder to use correctly, but is often faster for the cases it can handle printf-style String Formatting.

The Text Processing Services section of the standard library covers a number of other modules that provide various text related utilities including regular expression support in the re module. This means that characters like digraphs will only have their first letter capitalized, instead of the full character. Casefolding is similar to lowercasing but more aggressive because it is intended to remove all case distinctions in a string.

For example, the German lowercase letter 'ß' is equivalent to "ss". Since it is already lowercase, lower would do nothing to 'ß' ; casefold converts it to "ss". Return centered in a string of length width. Padding is done using the specified fillchar default is an ASCII space. The original string is returned if width is less than or equal to len s. Return the number of non-overlapping occurrences of substring sub in the range [ start , end ].

Optional arguments start and end are interpreted as in slice notation. If sub is empty, returns the number of empty strings between characters which is the length of the string plus one. Return an encoded version of the string as a bytes object. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme.

The default for errors is 'strict' , meaning that encoding errors raise a UnicodeError. Other possible values are 'ignore' , 'replace' , 'xmlcharrefreplace' , 'backslashreplace' and any other name registered via codecs.

For a list of possible encodings, see section Standard Encodings. By default, the errors argument is not checked for best performances, but only used at the first encoding error.

Enable the Python Development Mode , or use a debug build to check errors. Return True if the string ends with the specified suffix , otherwise return False. suffix can also be a tuple of suffixes to look for. With optional start , test beginning at that position.

With optional end , stop comparing at that position. Return a copy of the string where all tab characters are replaced by one or more spaces, depending on the current column and the given tab size. Tab positions occur every tabsize characters default is 8, giving tab positions at columns 0, 8, 16 and so on. To expand the string, the current column is set to zero and the string is examined character by character. The tab character itself is not copied.

Any other character is copied unchanged and the current column is incremented by one regardless of how the character is represented when printed. Return the lowest index in the string where substring sub is found within the slice s[start:end]. Return -1 if sub is not found. The find method should be used only if you need to know the position of sub. To check if sub is a substring or not, use the in operator:. Perform a string formatting operation.

The string on which this method is called can contain literal text or replacement fields delimited by braces {}. Each replacement field contains either the numeric index of a positional argument, or the name of a keyword argument.

Returns a copy of the string where each replacement field is replaced with the string value of the corresponding argument. See Format String Syntax for a description of the various formatting options that can be specified in format strings. When formatting a number int , float , complex , decimal. Decimal and subclasses with the n type ex: '{:n}'. This temporary change affects other threads. Similar to str. This is useful if for example mapping is a dict subclass:. Like find , but raise ValueError when the substring is not found.

Return True if all characters in the string are alphanumeric and there is at least one character, False otherwise. A character c is alphanumeric if one of the following returns True : c. isalpha , c. isdecimal , c. isdigit , or c. Return True if all characters in the string are alphabetic and there is at least one character, False otherwise. Return True if the string is empty or all characters in the string are ASCII, False otherwise. Return True if all characters in the string are decimal characters and there is at least one character, False otherwise.

Decimal characters are those that can be used to form numbers in base 10, e. Return True if all characters in the string are digits and there is at least one character, False otherwise. Digits include decimal characters and digits that need special handling, such as the compatibility superscript digits.

This covers digits which cannot be used to form numbers in base 10, like the Kharosthi numbers. Return True if the string is a valid identifier according to the language definition, section Identifiers and keywords. Call keyword. iskeyword to test whether string s is a reserved identifier, such as def and class. Return True if all cased characters 4 in the string are lowercase and there is at least one cased character, False otherwise. Return True if all characters in the string are numeric characters, and there is at least one character, False otherwise.

Numeric characters include digit characters, and all characters that have the Unicode numeric value property, e. Return True if all characters in the string are printable or the string is empty, False otherwise. Note that printable characters in this context are those which should not be escaped when repr is invoked on a string.

It has no bearing on the handling of strings written to sys. stdout or sys. Return True if there are only whitespace characters in the string and there is at least one character, False otherwise. Return True if the string is a titlecased string and there is at least one character, for example uppercase characters may only follow uncased characters and lowercase characters only cased ones.

Return False otherwise. Return True if all cased characters 4 in the string are uppercase and there is at least one cased character, False otherwise. Return a string which is the concatenation of the strings in iterable. A TypeError will be raised if there are any non-string values in iterable , including bytes objects. The separator between elements is the string providing this method. Return the string left justified in a string of length width.

Return a copy of the string with all the cased characters 4 converted to lowercase. Return a copy of the string with leading characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or None , the chars argument defaults to removing whitespace. The chars argument is not a prefix; rather, all combinations of its values are stripped:.

See str. removeprefix for a method that will remove a single prefix string rather than all of a set of characters. This static method returns a translation table usable for str. If there is only one argument, it must be a dictionary mapping Unicode ordinals integers or characters strings of length 1 to Unicode ordinals, strings of arbitrary lengths or None. Character keys will then be converted to ordinals.

If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y. If there is a third argument, it must be a string, whose characters will be mapped to None in the result. Split the string at the first occurrence of sep , and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator.

If the separator is not found, return a 3-tuple containing the string itself, followed by two empty strings. If the string starts with the prefix string, return string[len prefix :]. Otherwise, return a copy of the original string:. If the string ends with the suffix string and that suffix is not empty, return string[:-len suffix ].

Return a copy of the string with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced. Return the highest index in the string where substring sub is found, such that sub is contained within s[start:end]. Return -1 on failure. Like rfind but raises ValueError when the substring sub is not found.

Return the string right justified in a string of length width. Split the string at the last occurrence of sep , and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing two empty strings, followed by the string itself. Return a list of the words in the string, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done, the rightmost ones.

If sep is not specified or None , any whitespace string is a separator. Except for splitting from the right, rsplit behaves like split which is described in detail below. Return a copy of the string with trailing characters removed. The following methods can be defined to customize the meaning of attribute access use of, assignment to, or deletion of x.

name for class instances. This method should either return the computed attribute value or raise an AttributeError exception. Note that at least for instance variables, you can fake total control by not inserting any values in the instance attribute dictionary but instead inserting them in another object.

Called unconditionally to implement attribute accesses for instances of the class. This method should return the computed attribute value or raise an AttributeError exception. In order to avoid infinite recursion in this method, its implementation should always call the base class method with the same name to access any attributes it needs, for example, object.

This method may still be bypassed when looking up special methods as the result of implicit invocation via language syntax or built-in functions. See Special method lookup. For certain sensitive attribute accesses, raises an auditing event object. Called when an attribute assignment is attempted. This is called instead of the normal mechanism i. store the value in the instance dictionary. name is the attribute name, value is the value to be assigned to it.

For certain sensitive attribute assignments, raises an auditing event object. This should only be implemented if del obj. name is meaningful for the object. For certain sensitive attribute deletions, raises an auditing event object. Called when dir is called on the object. A sequence must be returned. dir converts the returned sequence to a list and sorts it. If an attribute is not found on a module object through the normal lookup, i. If found, it is called with the attribute name and the result is returned.

If present, this function overrides the standard dir search on a module. For a more fine grained customization of the module behavior setting attributes, properties, etc. For example:. New in version 3. Called to get the attribute of the owner class class attribute access or of an instance of that class instance attribute access. The optional owner argument is the owner class, while instance is the instance that the attribute was accessed through, or None when the attribute is accessed through the owner.

Called to set the attribute on an instance instance of the owner class to a new value, value. See Invoking Descriptors for more details. For callables, it may indicate that an instance of the given type or a subclass is expected or required as the first positional argument for example, CPython sets this attribute for unbound methods that are implemented in C.

If any of those methods are defined for an object, it is said to be a descriptor. For instance, a. x has a lookup chain starting with a. However, if the looked-up value is an object defining one of the descriptor methods, then Python may override the default behavior and invoke the descriptor method instead. Where this occurs in the precedence chain depends on which descriptor methods were defined and how they were called. The starting point for descriptor invocation is a binding, a.

How the arguments are assembled depends on a :. The simplest and least common call is when user code directly invokes a descriptor method: x. If binding to an object instance, a. x is transformed into the call: type a.

If binding to a class, A. x is transformed into the call: A. A dotted lookup such as super A, a. x searches a. If not a descriptor, x is returned unchanged. For instance bindings, the precedence of descriptor invocation depends on which descriptor methods are defined.

In contrast, non-data descriptors can be overridden by instances. Python methods including those decorated with staticmethod and classmethod are implemented as non-data descriptors. Accordingly, instances can redefine and override methods.

This allows individual instances to acquire behaviors that differ from other instances of the same class. The property function is implemented as a data descriptor.

Accordingly, instances cannot override the behavior of a property. Attribute lookup speed can be significantly improved as well. This class variable can be assigned a string, iterable, or sequence of strings with variable names used by instances. Attempts to assign to an unlisted variable name raises AttributeError. If a class defines a slot also defined in a base class, the instance variable defined by the base class slot is inaccessible except by retrieving its descriptor directly from the base class.

This renders the meaning of the program undefined. In the future, a check may be added to prevent this. The values of the dictionary can be used to provide per-attribute docstrings that will be recognised by inspect. getdoc and displayed in the output of help.

Multiple inheritance with multiple slotted parent classes can be used, but only one parent is allowed to have attributes created by slots the other bases must have empty slot layouts - violations raise TypeError. This way, it is possible to write classes which change the behavior of subclasses.

This method is called whenever the containing class is subclassed. cls is then the new subclass. If defined as a normal instance method, this method is implicitly converted to a class method.

The default implementation object. The actual metaclass rather than the explicit hint can be accessed as type cls. When a class is created, type. Automatically called at the time the owning class owner is created.

The object has been assigned to name in that class:. See Creating the class object for more details. By default, classes are constructed using type. The class body is executed in a new namespace and the class name is bound locally to the result of type name, bases, namespace. The class creation process can be customized by passing the metaclass keyword argument in the class definition line, or by inheriting from an existing class that included such an argument. In the following example, both MyClass and MySubclass are instances of Meta :.

Any other keyword arguments that are specified in the class definition are passed through to all metaclass operations described below. If found, it is called with the original bases tuple. This method must return a tuple of classes that will be used instead of this base.

The tuple may be empty, in such case the original base is ignored. PEP - Core support for typing module and generic types. if no bases and no explicit metaclass are given, then type is used;. if an explicit metaclass is given and it is not an instance of type , then it is used directly as the metaclass;. if an instance of type is given as the explicit metaclass, or bases are defined, then the most derived metaclass is used.

The most derived metaclass is selected from the explicitly specified metaclass if any and the metaclasses i. type cls of all specified base classes. The most derived metaclass is one which is a subtype of all of these candidate metaclasses. If none of the candidate metaclasses meets that criterion, then the class definition will fail with TypeError.

Once the appropriate metaclass has been identified, then the class namespace is prepared. The class body is executed approximately as exec body, globals , namespace. The key difference from a normal call to exec is that lexical scoping allows the class body including any methods to reference names from the current and outer scopes when the class definition occurs inside a function.

However, even when the class definition occurs inside the function, methods defined inside the class still cannot see names defined at the class scope. This class object is the one that will be referenced by the zero-argument form of super. This allows the zero argument form of super to correctly identify the class being defined based on lexical scoping, while the class or instance that was used to make the current call is identified based on the first argument passed to the method.

CPython implementation detail: In CPython 3. If present, this must be propagated up to the type. Failing to do so will result in a RuntimeError in Python 3. When using the default metaclass type , or any metaclass that ultimately calls type. The type. After the class object is created, it is passed to the class decorators included in the class definition if any and the resulting object is bound in the local namespace as the defined class. When a new class is created by type.

The potential uses for metaclasses are boundless. The following methods are used to override the default behavior of the isinstance and issubclass built-in functions. In particular, the metaclass abc. Return true if instance should be considered a direct or indirect instance of class.

If defined, called to implement isinstance instance, class. Return true if subclass should be considered a direct or indirect subclass of class. If defined, called to implement issubclass subclass, class. Note that these methods are looked up on the type metaclass of a class. They cannot be defined as class methods in the actual class. This is consistent with the lookup of special methods that are called on instances, only in this case the instance is itself a class.

For example, the annotation list[int] might be used to signify a list in which all the elements are of type int. Documentation on how to implement generic classes that can be parameterized at runtime and understood by static type-checkers. Return an object representing the specialization of a generic class by type arguments found in key. As such, there is no need for it to be decorated with classmethod when it is defined.

In Python, all classes are themselves instances of other classes. An example of this can be found in the enum module:.

roughly translates to type x. The following methods can be defined to implement container objects. Containers usually are sequences such as lists or tuples or mappings like dictionaries , but can represent other containers as well. The collections. Mutable sequences should provide methods append , count , index , extend , insert , pop , remove , reverse and sort , like Python standard list objects.

Called to implement the built-in function len. CPython implementation detail: In CPython, the length is required to be at most sys. If the length is larger than sys. maxsize some features such as len may raise OverflowError.

Called to implement operator. Should return an estimated length for the object which may be greater or less than the actual length.

This method is purely an optimization and is never required for correctness. and so forth. Missing slice items are always filled in with None. Called to implement evaluation of self[key]. For sequence types, the accepted keys should be integers and slice objects.

If key is of an inappropriate type, TypeError may be raised; if of a value outside the set of indexes for the sequence after any special interpretation of negative values , IndexError should be raised. For mapping types, if key is missing not in the container , KeyError should be raised. for loops expect that an IndexError will be raised for illegal indexes to allow proper detection of the end of the sequence. Called to implement assignment to self[key].

This should only be implemented for mappings if the objects support changes to the values for keys, or if new keys can be added, or for sequences if elements can be replaced. Called to implement deletion of self[key]. This should only be implemented for mappings if the objects support removal of keys, or for sequences if elements can be removed from the sequence. Called by dict. This method is called when an iterator is required for a container. This method should return a new iterator object that can iterate over all the objects in the container.

For mappings, it should iterate over the keys of the container. Called if present by the reversed built-in to implement reverse iteration. It should return a new iterator object that iterates over all the objects in the container in reverse order.

The membership test operators in and not in are normally implemented as an iteration through a container. However, container objects can supply the following special method with a more efficient implementation, which also does not require the object be iterable.

Called to implement membership test operators. Should return true if item is in self , false otherwise.

For mapping objects, this should consider the keys of the mapping rather than the values or the key-item pairs. The following methods can be defined to emulate numeric objects. Methods corresponding to operations that are not supported by the particular kind of number implemented e.

If one of those methods does not support the operation with the supplied arguments, it should return NotImplemented. These functions are only called if the left operand does not support the corresponding operation 3 and the operands are of different types.

These methods should attempt to do the operation in-place modifying self and return the result which could be, but does not have to be, self. If a specific method is not defined, the augmented assignment falls back to the normal methods.

Otherwise, x. Called to implement the built-in functions complex , int and float. Should return a value of the appropriate type. index , and whenever Python needs to losslessly convert the numeric object to an integer object such as in slicing, or in the built-in bin , hex and oct functions.

Presence of this method indicates that the numeric object is an integer type. Must return an integer. Called to implement the built-in function round and math functions trunc , floor and ceil. A context manager is an object that defines the runtime context to be established when executing a with statement.

The context manager handles the entry into, and the exit from, the desired runtime context for the execution of the block of code. Context managers are normally invoked using the with statement described in section The with statement , but can also be used by directly invoking their methods. Typical uses of context managers include saving and restoring various kinds of global state, locking and unlocking resources, closing opened files, etc.

For more information on context managers, see Context Manager Types. Enter the runtime context related to this object. Exit the runtime context related to this object. The parameters describe the exception that caused the context to be exited. If the context was exited without an exception, all three arguments will be None. If an exception is supplied, and the method wishes to suppress the exception i.

Otherwise, the exception will be processed normally upon exit from this method. The specification, background, and examples for the Python with statement.

When using a class name in a pattern, positional arguments in the pattern are not allowed by default, i. case MyClass x, y is typically invalid without special support in MyClass. The text is expected to have been normalised to Unicode Normalization Form C canonical composition , as described in Unicode Technical Report Conforming ECMAScript implementations are not required to perform any normalisation of text, or behave as though they were performing normalisation of text, themselves.

ECMAScript source text is assumed to be a sequence of bit code units for the purposes of this specification. Such a source text may include sequences of bit code units that are not valid UTF character encodings. If an actual source text is encoded in a form other than bit code units it must be processed as if it was first converted to UTF Within a comment, such an escape sequence is effectively ignored as part of the comment.

Within a string literal or regular expression literal, the Unicode escape sequence contributes one character to the value of the literal. Within an identifier, the escape sequence contributes one character to the identifier.

ECMAScript differs from the Java programming language in the behaviour of Unicode escape sequences. In an ECMAScript program, a Unicode escape sequence occurring within a comment is never interpreted and therefore cannot contribute to termination of the comment.

Similarly, a Unicode escape sequence occurring within a string literal in an ECMAScript program always contributes a character to the String value of the literal and is never interpreted as a line terminator or as a quote mark that might terminate the string literal.

The source text of an ECMAScript program is first converted into a sequence of input elements, which are tokens, line terminators, comments, or white space. The source text is scanned from left to right, repeatedly taking the longest possible sequence of characters as the next input element. There are two goal symbols for the lexical grammar.

The InputElementRegExp symbol is used in other syntactic grammar contexts. NOTE There are no syntactic grammar contexts where both a leading division or division-assignment, and a leading RegularExpressionLiteral are permitted. This is not affected by semicolon insertion see 7. That is, the above example is interpreted in the same way as:.

The Unicode format-control characters i. It is useful to allow format-control characters in source text to facilitate editing and display. All format control characters may be used within comments, and within string literals and regular expression literals.

The special treatment of certain format-control characters outside of comments, string literals, and regular expression literals is summarised in Table 1. White space characters are used to improve source text readability and to separate tokens indivisible lexical units from each other, but are otherwise insignificant. White space characters may occur between any two tokens and at the start or end of input. White space characters may also occur within a StringLiteral or a RegularExpressionLiteral where they are considered significant characters forming part of the literal value or within a Comment , but cannot appear within any other kind of token.

ECMAScript implementations must recognise all of the white space characters defined in Unicode 3. Later editions of the Unicode Standard may define other white space characters. ECMAScript implementations may recognise white space characters from later editions of the Unicode Standard. Like white space characters, line terminator characters are used to improve source text readability and to separate tokens indivisible lexical units from each other.

However, unlike white space characters, line terminators have some influence over the behaviour of the syntactic grammar.

In general, line terminators may occur between any two tokens, but there are a few places where they are forbidden by the syntactic grammar. Line terminators also affect the process of automatic semicolon insertion 7. A line terminator cannot occur within any token except a StringLiteral. Line terminators may only occur within a StringLiteral token as part of a LineContinuation. A line terminator can occur within a MultiLineComment 7.

Only the characters in Table 3 are treated as line terminators. Other new line or line breaking characters are treated as white space but not as line terminators. It should be considered a single character for the purpose of reporting line numbers. However, the LineTerminator at the end of the line is not considered to be part of the single-line comment; it is recognised separately by the lexical grammar and becomes part of the stream of input elements for the syntactic grammar.

This point is very important, because it implies that the presence or absence of single-line comments does not affect the process of automatic semicolon insertion see 7. Comments behave like white space and are discarded except that, if a MultiLineComment contains a line terminator character, then the entire comment is considered to be a LineTerminator for purposes of parsing by the syntactic grammar.

NOTE The DivPunctuator and RegularExpressionLiteral productions define tokens, but are not included in the Token production. An Identifier is an IdentifierName that is not a ReservedWord see 7.

The Unicode identifier grammar is based on both normative and informative character categories specified by the Unicode Standard. The characters in the specified categories in version 3. Unicode escape sequences are also permitted in an IdentifierName , where they contribute a single character to the IdentifierName , as computed by the CV of the UnicodeEscapeSequence see 7. A UnicodeEscapeSequence cannot be used to put a character into an IdentifierName that would otherwise be illegal.

All interpretations of identifiers within this specification are based upon their actual characters regardless of whether or not an escape sequence was used to contribute any particular characters. Two IdentifierName that are canonically equivalent according to the Unicode standard are not equal unless they are represented by the exact same sequence of code units in other words, conforming ECMAScript implementations are only required to do bitwise comparison on IdentifierName values.

The intent is that the incoming source text has been converted to normalised form C before it reaches the compiler. ECMAScript implementations may recognise identifier characters defined in later editions of the Unicode Standard.

If portability is a concern, programmers should only employ identifier characters defined in Unicode 3. The definitions of the nonterminal UnicodeEscapeSequence is given in 7. A reserved word is an IdentifierName that cannot be used as an Identifier. The following tokens are ECMAScript keywords and may not be used as Identifiers in ECMAScript programs. The following words are used as keywords in proposed extensions and are therefore reserved to allow for the possibility of future adoption of those extensions.

The following tokens are also considered to be FutureReservedWords when they occur within strict mode code see The occurrence of any of these tokens within strict mode code in any context where the occurrence of a FutureReservedWord would produce an error must also produce an equivalent error:.

The value of the null literal null is the sole value of the Null type, namely null. The value of the Boolean literal true is a value of the Boolean type, namely true. The value of the Boolean literal false is a value of the Boolean type, namely false. The source character immediately following a NumericLiteral must not be an IdentifierStart or DecimalDigit. A numeric literal stands for a value of the Number type. This value is determined in two steps: first, a mathematical value MV is derived from the literal; second, this mathematical value is rounded as described below.

The MV of NumericLiteral :: DecimalLiteral is the MV of DecimalLiteral. The MV of NumericLiteral :: HexIntegerLiteral is the MV of HexIntegerLiteral. The MV of DecimalLiteral :: DecimalIntegerLiteral. is the MV of DecimalIntegerLiteral.

DecimalDigits is the MV of DecimalIntegerLiteral plus the MV of DecimalDigits times 10 — n , where n is the number of characters in DecimalDigit s. ExponentPart is the MV of DecimalIntegerLiteral times 10 e , where e is the MV of ExponentPart. DecimalDigits ExponentPart is the MV of DecimalIntegerLiteral plus the MV of DecimalDigits times 10 — n times 10 e , where n is the number of characters in DecimalDigit s and e is the MV of ExponentPart.

The MV of DecimalLiteral DecimalDigits is the MV of DecimalDigits times 10 — n , where n is the number of characters in DecimalDigit s.

DecimalDigits ExponentPart is the MV of DecimalDigits times 10 e — n , where n is the number of characters in DecimalDigit s and e is the MV of ExponentPart. The MV of DecimalLiteral :: DecimalIntegerLiteral is the MV of DecimalIntegerLiteral.

The MV of DecimalLiteral :: DecimalIntegerLiteral ExponentPart is the MV of DecimalIntegerLiteral times 10 e , where e is the MV of ExponentPart. The MV of DecimalIntegerLiteral :: 0 is 0.

The MV of DecimalIntegerLiteral :: NonZeroDigit is the MV of NonZeroDigit. The MV of DecimalIntegerLiteral :: NonZeroDigit DecimalDigits is the MV of NonZeroDigit times 10 n plus the MV of DecimalDigits , where n is the number of characters in DecimalDigits. The MV of DecimalDigits :: DecimalDigit is the MV of DecimalDigit. The MV of DecimalDigits :: DecimalDigits DecimalDigit is the MV of DecimalDigits times 10 plus the MV of DecimalDigit. The MV of ExponentPart :: ExponentIndicator SignedInteger is the MV of SignedInteger.

The MV of SignedInteger :: DecimalDigits is the MV of DecimalDigits. The MV of SignedInteger :: - DecimalDigits is the negative of the MV of DecimalDigits. The MV of DecimalDigit :: 0 or of HexDigit :: 0 is 0. The MV of DecimalDigit :: 1 or of NonZeroDigit :: 1 or of HexDigit :: 1 is 1. The MV of DecimalDigit :: 2 or of NonZeroDigit :: 2 or of HexDigit :: 2 is 2.

The MV of DecimalDigit :: 3 or of NonZeroDigit :: 3 or of HexDigit :: 3 is 3. The MV of DecimalDigit :: 4 or of NonZeroDigit :: 4 or of HexDigit :: 4 is 4. The MV of DecimalDigit :: 5 or of NonZeroDigit :: 5 or of HexDigit :: 5 is 5.

The MV of DecimalDigit :: 6 or of NonZeroDigit :: 6 or of HexDigit :: 6 is 6. The MV of DecimalDigit :: 7 or of NonZeroDigit :: 7 or of HexDigit :: 7 is 7. The MV of DecimalDigit :: 8 or of NonZeroDigit :: 8 or of HexDigit :: 8 is 8. The MV of DecimalDigit :: 9 or of NonZeroDigit :: 9 or of HexDigit :: 9 is 9.

The MV of HexDigit :: a or of HexDigit :: A is The MV of HexDigit :: b or of HexDigit :: B is The MV of HexDigit :: c or of HexDigit :: C is The MV of HexDigit :: d or of HexDigit :: D is The MV of HexDigit :: e or of HexDigit :: E is The MV of HexDigit :: f or of HexDigit :: F is The MV of HexIntegerLiteral :: 0x HexDigit is the MV of HexDigit.

The MV of HexIntegerLiteral :: 0X HexDigit is the MV of HexDigit. The MV of HexIntegerLiteral :: HexIntegerLiteral HexDigit is the MV of HexIntegerLiteral times 16 plus the MV of HexDigit. Once the exact MV for a numeric literal has been determined, it is then rounded to a value of the Number type. A digit is significant if it is not part of an ExponentPart and. A conforming implementation, when processing strict mode code see A string literal is zero or more characters enclosed in single or double quotes.

Each character may be represented by an escape sequence. All characters may appear literally in a string literal except for the closing quote character, backslash, carriage return, line separator, paragraph separator, and line feed. Any character may appear in the form of an escape sequence. The definition of the nonterminal HexDigit is given in 7. SourceCharacter is defined in clause 6.

A string literal stands for a value of the String type. The String value SV of the literal is described in terms of character values CV contributed by the various parts of the string literal. As part of this process, some characters within the string literal are interpreted as having a mathematical value MV , as described below or in 7. The SV of StringLiteral :: "" is the empty character sequence. The SV of StringLiteral :: '' is the empty character sequence.

The SV of StringLiteral :: " DoubleStringCharacters " is the SV of DoubleStringCharacters. The SV of StringLiteral :: ' SingleStringCharacters ' is the SV of SingleStringCharacters. The SV of DoubleStringCharacters :: DoubleStringCharacter is a sequence of one character, the CV of DoubleStringCharacter.

The SV of DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharacters is a sequence of the CV of DoubleStringCharacter followed by all the characters in the SV of DoubleStringCharacters in order.

The SV of SingleStringCharacters :: SingleStringCharacter is a sequence of one character, the CV of SingleStringCharacter. The SV of SingleStringCharacters :: SingleStringCharacter SingleStringCharacters is a sequence of the CV of SingleStringCharacter followed by all the characters in the SV of SingleStringCharacters in order. The CV of DoubleStringCharacter :: LineContinuation is the empty character sequence.

The CV of SingleStringCharacter :: LineContinuation is the empty character sequence. The CV of EscapeSequence :: CharacterEscapeSequence is the CV of the CharacterEscapeSequence. The CV of EscapeSequence :: HexEscapeSequence is the CV of the HexEscapeSequence. The CV of EscapeSequence :: UnicodeEscapeSequence is the CV of the UnicodeEscapeSequence. The CV of CharacterEscapeSequence :: SingleEscapeCharacter is the character whose code unit value is determined by the SingleEscapeCharacter according to Table The CV of CharacterEscapeSequence :: NonEscapeCharacter is the CV of the NonEscapeCharacter.

The CV of NonEscapeCharacter :: SourceCharacter but not one of EscapeCharacter or LineTerminator is the SourceCharacter character itself. The CV of HexEscapeSequence :: x HexDigit HexDigit is the character whose code unit value is 16 times the MV of the first HexDigit plus the MV of the second HexDigit.

The CV of UnicodeEscapeSequence :: u HexDigit HexDigit HexDigit HexDigit is the character whose code unit value is times the MV of the first HexDigit plus times the MV of the second HexDigit plus 16 times the MV of the third HexDigit plus the MV of the fourth HexDigit. NOTE A line terminator character cannot appear in a string literal, except as part of a LineContinuation to produce the empty character sequence.

A regular expression literal is an input element that is converted to a RegExp object see A RegExp object may also be created at runtime by new RegExp see The productions below describe the syntax for a regular expression literal and are used by the input element scanner to find the end of the regular expression literal.

The Strings of characters comprising the RegularExpressionBody and the RegularExpressionFlags are passed uninterpreted to the regular expression constructor, which interprets them according to its own, more stringent grammar.

An implementation may extend the regular expression constructor's grammar, but it must not extend the RegularExpressionBody and RegularExpressionFlags productions or the productions used by these productions. A regular expression literal evaluates to a value of the Object type that is an instance of the standard built-in constructor RegExp. This value is determined in two steps: first, the characters comprising the regular expression's RegularExpressionBody and RegularExpressionFlags production expansions are collected uninterpreted into two Strings Pattern and Flags, respectively.

Then each time the literal is evaluated, a new object is created as if by the expression new RegExp Pattern, Flags where RegExp is the standard built-in constructor with that name. The newly constructed object becomes the value of the RegularExpressionLiteral. If the call to new RegExp would generate an error as specified in Certain ECMAScript statements empty statement, variable statement, expression statement, do - while statement, continue statement, break statement, return statement, and throw statement must be terminated with semicolons.

Such semicolons may always appear explicitly in the source text. For convenience, however, such semicolons may be omitted from the source text in certain situations. These situations are described by saying that semicolons are automatically inserted into the source code token stream in those situations.

However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of a for statement see When a continue , break , return , or throw token is encountered and a LineTerminator is encountered before the next token, a semicolon is automatically inserted after the continue , break , return , or throw token.

An Expression in a return or throw statement should start on the same line as the return or throw token. An Identifier in a break or continue statement should be on the same line as the break or continue token. is not a valid sentence in the ECMAScript grammar, even with the automatic semicolon insertion rules. In contrast, the source.

is also not a valid ECMAScript sentence, but is transformed by automatic semicolon insertion into the following:. is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion because the semicolon is needed for the header of a for statement. Automatic semicolon insertion never inserts one of the two semicolons in the header of a for statement. is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion before the else token, even though no production of the grammar applies at that point, because an automatically inserted semicolon would then be parsed as an empty statement.

is not transformed by automatic semicolon insertion, because the parenthesised expression that begins the second line can be interpreted as an argument list for a function call:. In the circumstance that an assignment statement must begin with a left parenthesis, it is a good idea for the programmer to provide an explicit semicolon at the end of the preceding statement rather than to rely on automatic semicolon insertion.

Algorithms within this specification manipulate values each of which has an associated type. The possible value types are exactly those defined in this clause. Types are further subclassified into ECMAScript language types and specification types.

An ECMAScript language type corresponds to values that are directly manipulated by an ECMAScript programmer using the ECMAScript language. The ECMAScript language types are Undefined, Null, Boolean, String, Number, and Object. A specification type corresponds to meta-values that are used within algorithms to describe the semantics of ECMAScript language constructs and ECMAScript language types. The specification types are Reference , List , Completion , Property Descriptor , Property Identifier , Lexical Environment , and Environment Record.

Specification type values are specification artefacts that do not necessarily correspond to any specific entity within an ECMAScript implementation. Specification type values may be used to describe intermediate results of ECMAScript expression evaluation but such values cannot be stored as properties of objects or values of ECMAScript language variables. The Undefined type has exactly one value, called undefined. Any variable that has not been assigned a value has the value undefined.

The Boolean type represents a logical entity having two values, called true and false. The String type is generally used to represent textual data in a running ECMAScript program, in which case each element in the String is treated as a code unit value see Clause 6. Each element is regarded as occupying a position within the sequence. These positions are indexed with nonnegative integers.

The first element if any is at position 0, the next element if any at position 1, and so on. The length of a String is the number of elements i. The empty String has length zero and therefore contains no elements. When a String contains actual textual data, each element is considered to be a single UTF code unit.

Whether or not this is the actual storage format of a String, the characters within a String are numbered by their initial code unit element position as though they were represented using UTF All operations on Strings except as otherwise stated treat them as sequences of undifferentiated bit unsigned integers; they do not ensure the resulting String is in normalised form, nor do they ensure language-sensitive results.

NOTE The rationale behind this design was to keep the implementation of Strings as simple and high-performing as possible. The intent is that textual data coming into the execution environment from outside e. be converted to Unicode Normalised Form C before the running program sees it. Usually this would occur at the same time incoming text is converted from its original character encoding to Unicode and would impose no additional overhead.

Since it is recommended that ECMAScript source code be in Normalised Form C, string literals are guaranteed to be normalised if source text is guaranteed to be normalised , as long as they do not contain any Unicode escape sequences. Note that the NaN value is produced by the program expression NaN. In some implementations, external code might be able to detect a difference between various Not-a-Number values, but such behaviour is implementation-dependent; to ECMAScript code, all NaN values are indistinguishable from each other.

There are two other special values, called positive Infinity and negative Infinity. Half of these are positive numbers and half are negative numbers; for every finite positive Number value there is a corresponding negative value having the same magnitude.

Note that there is both a positive zero and a negative zero. A finite number has an odd significand if it is nonzero and the integer m used to express it in one of the two forms shown above is odd.

Otherwise, it has an even significand. Choose the member of this set that is closest in value to x. The result is the Number value for x. These operators accept any value of the Number type but first convert each such value to one of 2 32 integer values.

See the descriptions of the ToInt32 and ToUint32 operators in 9. An Object is a collection of properties. Each property is either a named data property, a named accessor property, or an internal property:. A named data property associates a name with an ECMAScript language value and a set of Boolean attributes. A named accessor property associates a name with one or two accessor functions, and a set of Boolean attributes.

The accessor functions are used to store or retrieve an ECMAScript language value that is associated with the property. An internal property has no name and is not directly accessible via ECMAScript language operators. Internal properties exist purely for specification purposes. There are two kinds of access for named non-internal properties: get and put , corresponding to retrieval and assignment, respectively. Attributes are used in this specification to define and explain the state of named properties.

A named data property associates a name with the attributes listed in Table 5. If the value of an attribute is not explicitly specified by this specification for a named property, the default value defined in Table 7 is used. This specification uses various internal properties to define the semantics of object values. These internal properties are not part of the ECMAScript language. They are defined by this specification purely for expository purposes.

An implementation of ECMAScript must behave as if it produced and operated upon internal properties in the manner described here. The names of internal properties are enclosed in double square brackets [[ ]]. When an algorithm uses an internal property of an object and the object does not implement the indicated internal property, a TypeError exception is thrown.

The Table 8 summarises the internal properties used by this specification that are applicable to all ECMAScript objects. The Table 9 summarises the internal properties used by this specification that are only applicable to some ECMAScript objects.

The descriptions in these tables indicate their behaviour for native ECMAScript objects, unless stated otherwise in this document for particular kinds of native ECMAScript objects. Host objects may support these internal properties with any implementation-dependent behaviour as long as it is consistent with the specific host object restrictions stated in this document.

The type names refer to the types defined in Clause 8 augmented by the following additional names. If a parameter name is the same as a type name then the name describes the type of the parameter.

Every object including host objects must implement all of the internal properties listed in Table 8. However, the [[DefaultValue]] internal method may, for some objects, simply throw a TypeError exception. All objects have an internal property called [[Prototype]]. The value of this property is either null or an object and is used for implementing inheritance.

Whether or not a native object can have a host object as its [[Prototype]] depends on the implementation. Every [[Prototype]] chain must have finite length that is, starting from any object, recursively accessing the [[Prototype]] internal property must eventually lead to a null value. Named data properties of the [[Prototype]] object are inherited are visible as properties of the child object for the purposes of get access, but not for put access. Named accessor properties are inherited for both get access and put access.

Every ECMAScript object has a Boolean-valued [[Extensible]] internal property that controls whether or not named properties may be added to the object. If the value of the [[Extensible]] internal property is false then additional named properties may not be added to the object. In addition, if [[Extensible]] is false the value of the [[Class]] and [[Prototype]] internal properties of the object may not be modified. Once the value of an [[Extensible]] internal property has been set to false it may not be subsequently changed to true.

Implementation specific extensions that modify [[Class]], [[Prototype]] or [[Extensible]] must not violate the invariants defined in the preceding paragraph. The value of the [[Class]] internal property is defined by this specification for every kind of built-in object.

The value of the [[Class]] internal property of a host object may be any String value except one of "Arguments" , "Array" , "Boolean" , "Date" , "Error" , "Function" , "JSON" , "Math" , "Number" , "Object" , "RegExp" , and "String". The value of a [[Class]] internal property is used internally to distinguish different kinds of objects. Note that this specification does not provide any means for a program to access that value except through Object.

toString see Unless otherwise specified, the common internal methods of native ECMAScript objects behave as described in 8. Array objects have a slightly different implementation of the [[DefineOwnProperty]] internal method see Arguments objects Function objects Host objects may implement these internal methods in any manner unless specified otherwise; for example, one possibility is that [[Get]] and [[Put]] for a particular host object indeed fetch and store property values but [[HasProperty]] always generates false.

However, if any specified manipulation of a host object's internal properties is not supported by an implementation, that manipulation must throw a TypeError exception when attempted. The [[GetOwnProperty]] internal method of a host object must conform to the following invariants for each property of the host object:.

If a property is described as a data property and it may return different values over time, then either or both of the [[Writable]] and [[Configurable]] attributes must be true even if no mechanism to change the value is exposed via the other internal methods. If a property is described as a data property and its [[Writable]] and [[Configurable]] are both false , then the SameValue according to 9. If the attributes other than [[Writable]] may change over time or if the property might disappear, then the [[Configurable]] attribute must be true.

If the [[Writable]] attribute may change from false to true , then the [[Configurable]] attribute must be true. The [[DefineOwnProperty]] internal method of a host object must not permit the addition of a new property to a host object if the [[Extensible]] internal property of that host object has been observed by ECMAScript code to be false. If the [[Extensible]] internal property of that host object has been observed by ECMAScript code to be false then it must not subsequently become true.

The Reference type is used to explain the behaviour of such operators as delete , typeof , and the assignment operators. For example, the left-hand operand of an assignment is expected to produce a reference. The behaviour of assignment could, instead, be explained entirely in terms of a case analysis on the syntactic form of the left-hand operand of an assignment operator, but for one difficulty: function calls are permitted to return references.

This possibility is admitted purely for the sake of host objects. No built-in ECMAScript function defined by this specification returns a reference and there is no provision for a user-defined function to return a reference. Another reason not to use a syntactic case analysis is that it would be lengthy and awkward, affecting many parts of the specification.

A Reference is a resolved name binding. A Reference consists of three components, the base value, the referenced name and the Boolean valued strict reference flag. The base value is either undefined , an Object, a Boolean, a String, a Number, or an environment record A base value of undefined indicates that the reference could not be resolved to a binding. The referenced name is a String. The following abstract operations are used in this specification to access the components of references:.

IsPropertyReference V. Returns true if either the base value is an object or HasPrimitiveBase V is true ; otherwise returns false. IsUnresolvableReference V. Returns true if the base value is undefined and false otherwise. The following [[Get]] internal method is used by GetValue when V is a property reference with a primitive base value. It is called using base as its this value and with property P as its argument.

The following steps are taken:. NOTE The object that may be created in step 1 is not accessible outside of the above method. An implementation might choose to avoid the actual creation of the object. The only situation where such an actual property access that uses this internal method can have visible effect is when it invokes an accessor function.

The following [[Put]] internal method is used by PutValue when V is a property reference with a primitive base value. It is called using base as its this value and with property P , value W , and Boolean flag Throw as arguments.

An implementation might choose to avoid the actual creation of that transient object. The only situations where such an actual property assignment that uses this internal method can have visible effect are when it either invokes an accessor function or is in violation of a Throw predicated error check.

When Throw is true any property assignment that would create a new property on the transient object throws an error. The List type is used to explain the evaluation of argument lists see Values of the List type are simply ordered sequences of values.

These sequences may be of any length. The Completion type is used to explain the behaviour of statements break , continue , return and throw that perform nonlocal transfers of control. Values of the Completion type are triples of the form type , value , target , where type is one of normal , break , continue , return , or throw , value is any ECMAScript language value or empty , and target is any ECMAScript identifier or empty.

If cv is a completion value then cv. type , cv. value , and cv. target may be used to directly refer to its constituent values. The Property Descriptor type is used to explain the manipulation and reification of named property attributes.

In addition, any field may be present or absent. Property Descriptor values may be further classified as data property descriptors and accessor property descriptors based upon the existence or use of certain fields.

A data property descriptor is one that includes any fields named either [[Value]] or [[Writable]]. An accessor property descriptor is one that includes any fields named either [[Get]] or [[Set]].

This is the HTML rendering of Ecma Edition 5. The PDF version is the definitive specification. Any discrepancies between this HTML version and the PDF version are unintentional. This document and possible translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published, and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this section are included on all such copies and derivative works.

However, this document itself may not be modified in any way, including by removing the copyright notice or references to Ecma International, except as needed for the purpose of developing any document or deliverable produced by Ecma International in which case the rules applied to copyrights must be followed or as required to translate it into languages other than English. The limited permissions granted above are perpetual and will not be revoked by Ecma International or its successors or assigns.

All Software contained in this document "Software " is protected by copyright and is being made available under the "BSD License", included below. This Software may be subject to third party rights rights from parties other than Ecma International , including patent rights, and no licenses under such third party rights are granted under this license even if the third party concerned is a member of Ecma International.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Neither the name of the authors nor Ecma International may be used to endorse or promote products derived from this software without specific prior written permission.

This Ecma Standard is based on several originating technologies, the most well known being JavaScript Netscape and JScript Microsoft. It has appeared in all subsequent browsers from Netscape and in all browsers from Microsoft starting with Internet Explorer 3. The development of this Standard started in November The first edition of this Ecma Standard was adopted by the Ecma General Assembly of June Changes between the first and the second edition are editorial in nature.

Since publication of the third edition, ECMAScript has achieved massive adoption in conjunction with the World Wide Web where it has become the programming language that is supported by essentially all web browsers.

Significant work was done to develop a fourth edition of ECMAScript. Although that work was not completed and not published as the fourth edition of ECMAScript, it informs continuing evolution of the language.

The fifth edition of ECMAScript published as ECMA 5 th edition codifies de facto interpretations of the language specification that have become common among browser implementations and adds support for new features that have emerged since the publication of the third edition. Such features include accessor properties, reflective creation and inspection of objects, program control of property attributes, additional array manipulation functions, support for the JSON object encoding format, and a strict mode that provides enhanced error checking and program security.

This present edition 5. ECMAScript is a vibrant language and the evolution of the language is not complete. Significant technical enhancement will continue with future editions of this specification. A conforming implementation of ECMAScript must provide and support all the types, values, objects, properties, functions, and program syntax and semantics described in this specification.

A conforming implementation of this Standard shall interpret characters in conformance with the Unicode Standard, Version 3. If the adopted encoding form is not otherwise specified, it presumed to be the UTF encoding form. A conforming implementation of ECMAScript is permitted to provide additional types, values, objects, properties, and functions beyond those described in this specification.

In particular, a conforming implementation of ECMAScript is permitted to provide properties not described in this specification, and values for those properties, for objects that are described in this specification.

A conforming implementation of ECMAScript is permitted to support program and regular expression syntax not described in this specification.

The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document including any amendments applies.

ECMAScript is an object-oriented programming language for performing computations and manipulating computational objects within a host environment. ECMAScript as defined here is not intended to be computationally self-sufficient; indeed, there are no provisions in this specification for input of external data or output of computed results. Instead, it is expected that the computational environment of an ECMAScript program will provide not only the objects and other facilities described in this specification but also certain environment-specific host objects, whose description and behaviour are beyond the scope of this specification except to indicate that they may provide certain properties that can be accessed and certain functions that can be called from an ECMAScript program.

A scripting language is a programming language that is used to manipulate, customise, and automate the facilities of an existing system. In such systems, useful functionality is already available through a user interface, and the scripting language is a mechanism for exposing that functionality to program control. In this way, the existing system is said to provide a host environment of objects and facilities, which completes the capabilities of the scripting language.

A scripting language is intended for use by both professional and non-professional programmers. ECMAScript was originally designed to be a Web scripting language , providing a mechanism to enliven Web pages in browsers and to perform server computation as part of a Web-based client-server architecture.

ECMAScript can provide core scripting capabilities for a variety of host environments, and therefore the core scripting language is specified in this document apart from any particular host environment. Gosling, James, Bill Joy and Guy Steele. Addison Wesley Publishing Co. Ungar, David, and Smith, Randall B. Self: The Power of Simplicity. OOPSLA '87 Conference Proceedings, pp. IEEE Standard for the Scheme Programming Language. IEEE Std Further, the host environment provides a means to attach scripting code to events such as change of focus, page and image loading, unloading, error and abort, selection, form submission, and mouse actions.

Scripting code appears within the HTML and the displayed page is a combination of user interface elements and fixed and computed text and images.

The scripting code is reactive to user interaction and there is no need for a main program. A web server provides a different host environment for server-side computation including objects representing requests, clients, and files; and mechanisms to lock and share data. By using browser-side and server-side scripting together, it is possible to distribute computation between the client and server while providing a customised user interface for a Web-based application. Each Web browser and server that supports ECMAScript supplies its own host environment, completing the ECMAScript execution environment.

The following is an informal overview of ECMAScript—not all parts of the language are described. This overview is not part of the standard proper. ECMAScript is object-based: basic language and host facilities are provided by objects, and an ECMAScript program is a cluster of communicating objects.

An ECMAScript object is a collection of properties each with zero or more attributes that determine how each property can be used—for example, when the Writable attribute for a property is set to false , any attempt by executed ECMAScript code to change the value of the property fails. Properties are containers that hold other objects, primitive values , or functions.

A primitive value is a member of one of the following built-in types: Undefined , Null , Boolean , Number , and String ; an object is a member of the remaining built-in type Object ; and a function is a callable object. A function that is associated with an object via a property is a method. ECMAScript defines a collection of built-in objects that round out the definition of ECMAScript entities.

These built-in objects include the global object, the Object object, the Function object, the Array object, the String object, the Boolean object, the Number object, the Math object, the Date object, the RegExp object, the JSON object, and the Error objects Error, EvalError , RangeError, ReferenceError, SyntaxError, TypeError and URIError.

ECMAScript also defines a set of built-in operators. ECMAScript operators include various unary operations, multiplicative operators, additive operators, bitwise shift operators, relational operators, equality operators, binary bitwise operators, binary logical operators, assignment operators, and the comma operator.

ECMAScript syntax intentionally resembles Java syntax. ECMAScript syntax is relaxed to enable it to serve as an easy-to-use scripting language. For example, a variable is not required to have its type declared nor are types associated with properties, and defined functions are not required to have their declarations appear textually before calls to them.

Instead objects may be created in various ways including via a literal notation or via constructors which create objects and then execute code that initialises all or part of them by assigning initial values to their properties. Objects are created by using constructors in new expressions; for example, new Date ,11 creates a new Date object.

Invoking a constructor without using new has consequences that depend on the constructor. For example, Date produces a string representation of the current date and time rather than an object. Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called the prototype chain. When a reference is made to a property in an object, that reference is to the property of that name in the first object in the prototype chain that contains a property of that name.

In other words, first the object mentioned directly is examined for such a property; if that object contains the named property, that is the property to which the reference refers; if that object does not contain the named property, the prototype for that object is examined next; and so on. In a class-based object-oriented language, in general, state is carried by instances, methods are carried by classes, and inheritance is only of structure and behaviour.

In ECMAScript, the state and methods are carried by objects, and structure, behaviour, and state are all inherited. All objects that do not directly contain a particular property that their prototype contains share that property and its value. Figure 1 illustrates this:. CF is a constructor and also an object. Five objects have been created by using new expressions: cf 1 , cf 2 , cf 3 , cf 4 , and cf 5.

Each of these objects contains properties named q1 and q2. The constructor, CF , has two properties itself, named P1 and P2 , which are not visible to CF p , cf 1 , cf 2 , cf 3 , cf 4 , or cf 5. Notice that there is no implicit prototype link between CF and CF p. Unlike class-based object languages, properties can be added to objects dynamically by assigning values to them. In the above diagram, one could add a new shared property for cf 1 , cf 2 , cf 3 , cf 4 , and cf 5 by assigning a new value to the property in CF p.

The ECMAScript Language recognises the possibility that some users of the language may wish to restrict their usage of some features available in the language. They might do so in the interests of security, to avoid what they consider to be error-prone features, to get enhanced error checking, or for other reasons of their choosing. In support of this possibility, ECMAScript defines a strict variant of the language. The strict variant of the language excludes some specific syntactic and semantic features of the regular ECMAScript language and modifies the detailed semantics of some features.

The strict variant also specifies additional error conditions that must be reported by throwing error exceptions in situations that are not specified as errors by the non-strict form of the language.

The strict variant of ECMAScript is commonly referred to as the strict mode of the language. Strict mode selection and use of the strict mode syntax and semantics of ECMAScript is explicitly made at the level of individual ECMAScript code units.

Because strict mode is selected at the level of a syntactic code unit, strict mode only imposes restrictions that have local effect within such a code unit. Strict mode does not restrict or modify any aspect of the ECMAScript semantics that must operate consistently across multiple code units. A complete ECMAScript program may be composed for both strict mode and non-strict mode ECMAScript code units.

In this case, strict mode only applies when actually executing code that is defined within a strict mode code unit.

In order to conform to this specification, an ECMAScript implementation must implement both the full unrestricted ECMAScript language and the strict mode variant of the ECMAScript language as defined by this specification.

Identifier resolution is the process of determining the binding of an Identifier using the LexicalEnvironment of the running execution context. NOTE A String object is created by using the String constructor in a new expression, supplying a String value as an argument. The following methods can be defined to implement container objects. Only enable inlining and cloning optimizations, which includes inlining, cloning, interprocedural scalar replacement of aggregates and partial inlining. Return a copy of the sequence with specified leading and trailing bytes removed.

Categories:

• Binary Options online
• Forex Bitcoin
• Forex Brokers
• Forex
• Binary Options