Hàm tích hợp python nào trả về số duy nhất được gán cho một đối tượng

3. 2. Hệ thống phân cấp loại tiêu chuẩn¶

Dưới đây là danh sách các loại được tích hợp sẵn trong Python. Các mô-đun mở rộng [được viết bằng C, Java hoặc các ngôn ngữ khác, tùy thuộc vào việc triển khai] có thể xác định các loại bổ sung. Các phiên bản tương lai của Python có thể thêm các loại vào hệ thống phân cấp loại [e. g. , số hữu tỷ, mảng số nguyên được lưu trữ hiệu quả, v.v. ], mặc dù những phần bổ sung như vậy thường sẽ được cung cấp thông qua thư viện chuẩn để thay thế

Một số mô tả loại bên dưới chứa đoạn liệt kê 'thuộc tính đặc biệt. ' Đây là những thuộc tính cung cấp quyền truy cập vào việc triển khai và không dành cho mục đích sử dụng chung. Định nghĩa của họ có thể thay đổi trong tương lai

Loại này có một giá trị duy nhất. Có một đối tượng duy nhất với giá trị này. Đối tượng này được truy cập thông qua tên dựng sẵn

# id of 5
print["id of 5 =", id[5]]

a = 5

# id of a
print["id of a =", id[a]]

b = a

# id of b
print["id of b =", id[b]]

c = 5.0

# id of c
print["id of c =", id[c]]

Loại này có một giá trị duy nhất. Có một đối tượng duy nhất với giá trị này. Đối tượng này được truy cập thông qua tên dựng sẵn

# id of 5
print["id of 5 =", id[5]]

a = 5

# id of a
print["id of a =", id[a]]

b = a

# id of b
print["id of b =", id[b]]

c = 5.0

# id of c
print["id of c =", id[c]]

Xem Thực hiện các phép toán số học để biết thêm chi tiết.

Đã thay đổi trong phiên bản 3. 9. Đánh giá

# id of 5
print["id of 5 =", id[5]]

a = 5

# id of a
print["id of a =", id[a]]

b = a

# id of b
print["id of b =", id[b]]

c = 5.0

# id of c
print["id of c =", id[c]]

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

This type has a single value. There is a single object with this value. This object is accessed through the literal

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

These are created by numeric literals and returned as results by arithmetic operators and arithmetic built-in functions. Numeric objects are immutable; once created their value never changes. Python numbers are of course strongly related to mathematical numbers, but subject to the limitations of numerical representation in computers

The string representations of the numeric classes, computed by

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

• They are valid numeric literals which, when passed to their class constructor, produce an object having the value of the original numeric

• The representation is in base 10, when possible

• Leading zeros, possibly excepting a single zero before a decimal point, are not shown

• Trailing zeros, possibly excepting a single zero after a decimal point, are not shown

• A sign is shown only when the number is negative

Python distinguishes between integers, floating point numbers, and complex numbers

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

These represent elements from the mathematical set of integers [positive and negative]

There are two types of integers

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

These represent numbers in an unlimited range, subject to available [virtual] memory only. For the purpose of shift and mask operations, a binary representation is assumed, and negative numbers are represented in a variant of 2’s complement which gives the illusion of an infinite string of sign bits extending to the left

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

These represent the truth values False and True. The two objects representing the values

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

The rules for integer representation are intended to give the most meaningful interpretation of shift and mask operations involving negative integers

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

Chúng đại diện cho các số dấu phẩy động chính xác kép ở cấp độ máy. You are at the mercy of the underlying machine architecture [and C or Java implementation] for the accepted range and handling of overflow. Python does not support single-precision floating point numbers; the savings in processor and memory usage that are usually the reason for using these are dwarfed by the overhead of using objects in Python, so there is no reason to complicate the language with two kinds of floating point numbers

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

These represent complex numbers as a pair of machine-level double precision floating point numbers. The same caveats apply as for floating point numbers. The real and imaginary parts of a complex number

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

These represent finite ordered sets indexed by non-negative numbers. The built-in function

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

Sequences also support slicing.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

Một số trình tự cũng hỗ trợ “cắt lát mở rộng” với tham số “bước” thứ ba.

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

import sys
from types import ModuleType

class VerboseModule[ModuleType]:
    def __repr__[self]:
        return f'Verbose {self.__name__}'

    def __setattr__[self, attr, value]:
        print[f'Setting {attr}...']
        super[].__setattr__[attr, value]

sys.modules[__name__].__class__ = VerboseModule

Sequences are distinguished according to their mutability

An object of an immutable sequence type cannot change once it is created. [If the object contains references to other objects, these other objects may be mutable and may be changed; however, the collection of objects directly referenced by an immutable object cannot change. ]

The following types are immutable sequences

A string is a sequence of values that represent Unicode code points. All the code points in the range

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

class Philosopher:
    def __init_subclass__[cls, /, default_name, **kwargs]:
        super[].__init_subclass__[**kwargs]
        cls.default_name = default_name

class AustralianPhilosopher[Philosopher, default_name="Bruce"]:
    pass

The items of a tuple are arbitrary Python objects. Tuples of two or more items are formed by comma-separated lists of expressions. A tuple of one item [a ‘singleton’] can be formed by affixing a comma to an expression [an expression by itself does not create a tuple, since parentheses must be usable for grouping of expressions]. An empty tuple can be formed by an empty pair of parentheses

A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0