search

Gấp đôi :: trong Python là gì?

1 năms trước
Trả lời: 0
Lượt xem: 9

Một số lớp bộ sưu tập có thể thay đổi. Các phương thức cộng, trừ hoặc sắp xếp lại các thành viên của chúng tại chỗ và không trả về một mục cụ thể, không bao giờ trả về chính thể hiện của bộ sưu tập nhưng 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31

Show

Một số hoạt động được hỗ trợ bởi một số loại đối tượng; . Hàm thứ hai được sử dụng ngầm khi một đối tượng được viết bởi hàm

Kiểm tra giá trị thật

Bất kỳ đối tượng nào cũng có thể được kiểm tra giá trị thực, để sử dụng trong một hoặc điều kiện hoặc dưới dạng toán hạng của các phép toán Boolean bên dưới

Theo mặc định, một đối tượng được coi là đúng trừ khi lớp của nó định nghĩa phương thức 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
37 trả về 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 hoặc phương thức 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
39 trả về 0 khi được gọi với đối tượng. Dưới đây là hầu hết các đối tượng tích hợp được coi là sai

  • hằng số được xác định là sai. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    31 and 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    38

  • số không của bất kỳ loại số nào. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    43, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    44, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    45, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    46

  • trình tự và bộ sưu tập trống. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    47, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    48, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    49, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    50, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    51, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    52

Các phép toán và hàm dựng sẵn có kết quả Boolean luôn trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
42 hoặc 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 nếu sai và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
55 hoặc 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu đúng, trừ khi có quy định khác. (Ngoại lệ quan trọng. các phép toán Boolean 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
57 và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
58 luôn trả về một trong các toán hạng của chúng. )

Phép toán Boolean — def bit_length(self): s = bin(self) # binary representation: bin(-37) --> '-0b100101' s = s.lstrip('-0b') # remove leading zeros and minus sign return len(s) # len('100101') --> 6 58, def bit_length(self): s = bin(self) # binary representation: bin(-37) --> '-0b100101' s = s.lstrip('-0b') # remove leading zeros and minus sign return len(s) # len('100101') --> 6 57, def bit_length(self): s = bin(self) # binary representation: bin(-37) --> '-0b100101' s = s.lstrip('-0b') # remove leading zeros and minus sign return len(s) # len('100101') --> 6 61

Đây là các phép toán Boolean, được sắp xếp theo mức độ ưu tiên tăng dần

Hoạt động

Kết quả

ghi chú

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
62

nếu x sai, thì y, ngược lại x

(1)

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
63

nếu x sai, thì x, ngược lại y

(2)

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
64

nếu x sai, thì 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56, ngược lại thì 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38

(3)

ghi chú

  1. This is a short-circuit operator, so it only evaluates the second argument if the first one is false

  2. Đây là toán tử ngắn mạch, vì vậy nó chỉ đánh giá đối số thứ hai nếu đối số thứ nhất đúng

  3. def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    61 có mức ưu tiên thấp hơn so với các toán tử không phải Boolean, vì vậy 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    68 được hiểu là 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    69 và 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    70 là một lỗi cú pháp

so sánh

There are eight comparison operations in Python. They all have the same priority (which is higher than that of the Boolean operations). Comparisons can be chained arbitrarily; for example, 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
71 is equivalent to 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
72, except that y is evaluated only once (but in both cases z is not evaluated at all when 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
73 is found to be false)

This table summarizes the comparison operations

Hoạt động

Meaning

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
74

strictly less than

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
75

less than or equal

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
76

strictly greater than

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
77

greater than or equal

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
78

equal

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
79

not equal

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
80

object identity

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
81

negated object identity

Objects of different types, except different numeric types, never compare equal. The 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
78 operator is always defined but for some object types (for example, class objects) is equivalent to . The 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
74, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
75, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
76 and 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
77 operators are only defined where they make sense; for example, they raise a exception when one of the arguments is a complex number

Non-identical instances of a class normally compare as non-equal unless the class defines the method

Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines enough of the methods , , , and (in general, and are sufficient, if you want the conventional meanings of the comparison operators)

The behavior of the and operators cannot be customized; also they can be applied to any two objects and never raise an exception

Two more operations with the same syntactic priority, and , are supported by types that are or implement the 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
00 method

Numeric Types — , ,

There are three distinct numeric types. integers, floating point numbers, and complex numbers. In addition, Booleans are a subtype of integers. Integers have unlimited precision. Floating point numbers are usually implemented using double in C; information about the precision and internal representation of floating point numbers for the machine on which your program is running is available in . Complex numbers have a real and imaginary part, which are each a floating point number. To extract these parts from a complex number z, use 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
05 and 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
06. (The standard library includes the additional numeric types , for rationals, and , for floating-point numbers with user-definable precision. )

Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals (including hex, octal and binary numbers) yield integers. Numeric literals containing a decimal point or an exponent sign yield floating point numbers. Appending 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
09 or 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
10 to a numeric literal yields an imaginary number (a complex number with a zero real part) which you can add to an integer or float to get a complex number with real and imaginary parts

Python fully supports mixed arithmetic. when a binary arithmetic operator has operands of different numeric types, the operand with the “narrower” type is widened to that of the other, where integer is narrower than floating point, which is narrower than complex. A comparison between numbers of different types behaves as though the exact values of those numbers were being compared.

The constructors , , and can be used to produce numbers of a specific type

Tất cả các loại số (ngoại trừ số phức) đều hỗ trợ các thao tác sau (để biết mức độ ưu tiên của các thao tác, xem phần )

Hoạt động

Kết quả

ghi chú

Full documentation

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
14

sum of x and y

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
15

difference of x and y

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
16

product of x and y

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
17

quotient of x and y

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
18

floored quotient of x and y

(1)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
19

remainder of 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
17

(2)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
21

x negated

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
22

x unchanged

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
23

absolute value or magnitude of x

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
25

x converted to integer

(3)(6)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
27

x converted to floating point

(4)(6)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
29

a complex number with real part re, imaginary part im. im defaults to zero

(6)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
31

conjugate of the complex number c

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
32

the pair 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
33

(2)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
35

x to the power y

(5)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
37

x to the power y

(5)

ghi chú

  1. Also referred to as integer division. The resultant value is a whole integer, though the result’s type is not necessarily int. The result is always rounded towards minus infinity. 

    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    38 is 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42, 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    40 is 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    41, 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    42 is 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    41, and 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    44 is 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42

  2. Not for complex numbers. Instead convert to floats using if appropriate

  3. Conversion from floating point to integer may round or truncate as in C; see functions and for well-defined conversions

  4. float also accepts the strings “nan” and “inf” with an optional prefix “+” or “-” for Not a Number (NaN) and positive or negative infinity

  5. Python defines 

    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    49 and 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    50 to be 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    55, as is common for programming languages

  6. The numeric literals accepted include the digits 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42 to 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    53 or any Unicode equivalent (code points with the 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    54 property)

    See https. //www. unicode. org/Public/14. 0. 0/ucd/extracted/DerivedNumericType. txt for a complete list of code points with the 

    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    54 property

All types ( and ) also include the following operations

Hoạt động

Kết quả

x truncated to

x rounded to n digits, rounding half to even. Nếu n bị bỏ qua, nó mặc định là 0

lớn nhất <= x

nhỏ nhất >= x

Để biết các phép toán số bổ sung, hãy xem mô-đun và

Hoạt động Bitwise trên các loại số nguyên

Hoạt động bitwise chỉ có ý nghĩa đối với số nguyên. Kết quả của các hoạt động theo bit được tính toán như thể được thực hiện trong phần bù hai với số lượng bit dấu vô hạn

Tất cả các ưu tiên của các hoạt động bitwise nhị phân đều thấp hơn các hoạt động số và cao hơn so với các phép so sánh;

Bảng này liệt kê các hoạt động bitwise được sắp xếp theo mức độ ưu tiên tăng dần

Hoạt động

Kết quả

ghi chú

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
71

bitwise hoặc của x và y

(4)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
72

loại trừ theo bit hoặc của x và y

(4)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
73

bitwise và của x và y

(4)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
74

x dịch sang trái n bit

(1)(2)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
75

x dịch sang phải n bit

(1)(3)

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
76

các bit của x đảo ngược

ghi chú

  1. Số lần thay đổi âm là bất hợp pháp và gây ra một sự gia tăng

  2. Dịch trái n bit tương đương với phép nhân với 

    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    78

  3. Dịch chuyển sang phải n bit tương đương với phép chia sàn cho 

    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    78

  4. Thực hiện các phép tính này với ít nhất một bit mở rộng dấu phụ trong biểu diễn phần bù của hai hữu hạn (độ rộng bit làm việc là 

    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    80 trở lên) là đủ để có được kết quả tương tự như thể có vô số bit dấu

Các phương thức bổ sung trên các kiểu số nguyên

Kiểu int thực hiện. Ngoài ra nó còn cung cấp thêm một số phương pháp

int. bit_length()

Trả về số bit cần thiết để biểu diễn một số nguyên ở dạng nhị phân, không bao gồm dấu và các số 0 ở đầu

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

Chính xác hơn, nếu 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
82 khác 0, thì 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
83 là số nguyên dương duy nhất 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
84 sao cho 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
85. Tương tự, khi 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
23 đủ nhỏ để có logarit được làm tròn chính xác, thì 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
87. Nếu 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
82 bằng 0, thì 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
83 trả về 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
42

Tương đương với

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

Mới trong phiên bản 3. 1

int. bit_count()

Trả về số đơn vị trong biểu diễn nhị phân của giá trị tuyệt đối của số nguyên. This is also known as the population count. Example

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

Tương đương với

def bit_count(self):
    return bin(self).count("1")

New in version 3. 10

int. to_bytes(length=1 , byteorder='big' , * , signed=False)

Return an array of bytes representing an integer

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

The integer is represented using length bytes, and defaults to 1. An 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, and defaults to 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
92. If byteorder is 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
92, the most significant byte is at the beginning of the byte array. If byteorder is 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
94, the most significant byte is at the end of the byte array

The signed argument determines whether two’s complement is used to represent the integer. If signed is 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 and a negative integer is given, an is raised. The default value for signed is 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38

The default values can be used to conveniently turn an integer into a single byte object. However, when using the default arguments, don’t try to convert a value greater than 255 or you’ll get an 

>>> (65).to_bytes()
b'A'

Tương đương với

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)

New in version 3. 2

Changed in version 3. 11. Added default argument values for 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
99 and 
def bit_count(self):
    return bin(self).count("1")
00.

classmethod int. from_bytes(bytes , byteorder='big' , * , signed=False)

Return the integer represented by the given array of bytes

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

The argument bytes must either be a or an iterable producing bytes

The byteorder argument determines the byte order used to represent the integer, and defaults to 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
92. If byteorder is 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
92, the most significant byte is at the beginning of the byte array. If byteorder is 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
94, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use as the byte order value

The signed argument indicates whether two’s complement is used to represent the integer

Tương đương với

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n

New in version 3. 2

Changed in version 3. 11. Added default argument value for 

def bit_count(self):
    return bin(self).count("1")
00.

int. as_integer_ratio()

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 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
55 as the denominator

New in version 3. 8

Additional Methods on Float

The float type implements the . float also has the following additional methods

float. as_integer_ratio()

Return a pair of integers whose ratio is exactly equal to the original float and with a positive denominator. Raises on infinities and a on NaNs

float. is_integer()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if the float instance is finite with integral value, and 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

Two methods support conversion to and from hexadecimal strings. Since Python’s floats are stored internally as binary numbers, converting a float to or from a decimal string usually involves a small rounding error. In contrast, hexadecimal strings allow exact representation and specification of floating-point numbers. This can be useful when debugging, and in numerical work

float. hex()

Return a representation of a floating-point number as a hexadecimal string. For finite floating-point numbers, this representation will always include a leading 

def bit_count(self):
    return bin(self).count("1")
12 and a trailing 
def bit_count(self):
    return bin(self).count("1")
13 and exponent

classmethod float. fromhex(s)

Class method to return the float represented by a hexadecimal string s. The string s may have leading and trailing whitespace

Note that is an instance method, while is a class method

A hexadecimal string takes the form

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
0

where the optional 

def bit_count(self):
    return bin(self).count("1")
16 may by either 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
69 or 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
70, 
def bit_count(self):
    return bin(self).count("1")
19 and 
def bit_count(self):
    return bin(self).count("1")
20 are strings of hexadecimal digits, and 
def bit_count(self):
    return bin(self).count("1")
21 is a decimal integer with an optional leading sign. 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. 4. 4. 2 of the C99 standard, and also to the syntax used in Java 1. 5 onwards. In particular, the output of is usable as a hexadecimal floating-point literal in C or Java code, and hexadecimal strings produced by C’s 
def bit_count(self):
    return bin(self).count("1")
23 format character or Java’s 
def bit_count(self):
    return bin(self).count("1")
24 are accepted by

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 

def bit_count(self):
    return bin(self).count("1")
26 represents the floating-point number 
def bit_count(self):
    return bin(self).count("1")
27, or 
def bit_count(self):
    return bin(self).count("1")
28

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
1

Applying the reverse conversion to 

def bit_count(self):
    return bin(self).count("1")
28 gives a different hexadecimal string representing the same number

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
2

Hashing of numeric types

For numbers 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
82 and 
def bit_count(self):
    return bin(self).count("1")
31, possibly of different types, it’s a requirement that 
def bit_count(self):
    return bin(self).count("1")
32 whenever 
def bit_count(self):
    return bin(self).count("1")
33 (see the method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including , , and ) Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of and , and all finite instances of and . Essentially, this function is given by reduction modulo 
def bit_count(self):
    return bin(self).count("1")
43 for a fixed prime 
def bit_count(self):
    return bin(self).count("1")
43. The value of 
def bit_count(self):
    return bin(self).count("1")
43 is made available to Python as the 
def bit_count(self):
    return bin(self).count("1")
46 attribute of

CPython implementation detail. Hiện tại, số nguyên tố được sử dụng là 

def bit_count(self):
    return bin(self).count("1")
48 trên các máy có độ dài C 32 bit và 
def bit_count(self):
    return bin(self).count("1")
49 trên các máy có độ dài C 64 bit

Here are the rules in detail

  • If 

    def bit_count(self):
    return bin(self).count("1")
    50 is a nonnegative rational number and 
    def bit_count(self):
    return bin(self).count("1")
    51 is not divisible by 
    def bit_count(self):
    return bin(self).count("1")
    43, define 
    def bit_count(self):
    return bin(self).count("1")
    53 as 
    def bit_count(self):
    return bin(self).count("1")
    54, where 
    def bit_count(self):
    return bin(self).count("1")
    55 gives the inverse of 
    def bit_count(self):
    return bin(self).count("1")
    51 modulo 
    def bit_count(self):
    return bin(self).count("1")
    43

  • If 

    def bit_count(self):
    return bin(self).count("1")
    50 is a nonnegative rational number and 
    def bit_count(self):
    return bin(self).count("1")
    51 is divisible by 
    def bit_count(self):
    return bin(self).count("1")
    43 (but 
    def bit_count(self):
    return bin(self).count("1")
    61 is not) then 
    def bit_count(self):
    return bin(self).count("1")
    51 has no inverse modulo 
    def bit_count(self):
    return bin(self).count("1")
    43 and the rule above doesn’t apply; in this case define 
    def bit_count(self):
    return bin(self).count("1")
    53 to be the constant value 
    def bit_count(self):
    return bin(self).count("1")
    65

  • If 

    def bit_count(self):
    return bin(self).count("1")
    50 is a negative rational number define 
    def bit_count(self):
    return bin(self).count("1")
    53 as 
    def bit_count(self):
    return bin(self).count("1")
    68. If the resulting hash is 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    41, replace it with 
    def bit_count(self):
    return bin(self).count("1")
    70

  • The particular values 

    def bit_count(self):
    return bin(self).count("1")
    65 and 
    def bit_count(self):
    return bin(self).count("1")
    72 are used as hash values for positive infinity or negative infinity (respectively)

  • For a number 

    def bit_count(self):
    return bin(self).count("1")
    74, the hash values of the real and imaginary parts are combined by computing 
    def bit_count(self):
    return bin(self).count("1")
    75, reduced modulo 
    def bit_count(self):
    return bin(self).count("1")
    76 so that it lies in 
    def bit_count(self):
    return bin(self).count("1")
    77. Again, if the result is 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    41, it’s replaced with 
    def bit_count(self):
    return bin(self).count("1")
    70

To clarify the above rules, here’s some example Python code, equivalent to the built-in hash, for computing the hash of a rational number, , or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
3

Iterator Types

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 support

container. __iter__()

Return an 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. (Ví dụ về một đối tượng hỗ trợ nhiều hình thức lặp sẽ là một cấu trúc cây hỗ trợ cả truyền tải theo chiều rộng và theo chiều sâu. ) This method corresponds to the slot of the type structure for Python objects in the Python/C API

The iterator objects themselves are required to support the following two methods, which together form the iterator protocol

iterator. __iter__()

Return the object itself. This is required to allow both containers and iterators to be used with the and statements. This method corresponds to the slot of the type structure for Python objects in the Python/C API

iterator. __next__()

Return the next item from the . If there are no further items, raise the exception. This method corresponds to the slot of the type structure for Python objects in the Python/C API

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

Once an iterator’s method raises , it must continue to do so on subsequent calls. Implementations that do not obey this property are deemed broken

Generator Types

Python’s s provide a convenient way to implement the iterator protocol. If a container object’s 

def bit_count(self):
    return bin(self).count("1")
90 method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the 
def bit_count(self):
    return bin(self).count("1")
90 and methods. More information about generators can be found in

Sequence Types — , ,

There are three basic sequence types. lists, tuples, and range objects. Additional sequence types tailored for processing of and are described in dedicated sections

Common Sequence Operations

The operations in the following table are supported by most sequence types, both mutable and immutable. The 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 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
98 and 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
99 operations have the same priorities as the comparison operations. The 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
69 (concatenation) and 
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
00 (repetition) operations have the same priority as the corresponding numeric operations.

Hoạt động

Kết quả

ghi chú

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
01

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if an item of s is equal to x, else 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38

(1)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
04

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 nếu một phần tử của s bằng x, ngược lại 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56

(1)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
07

the concatenation of s and t

(6)(7)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
08 or 
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
09

equivalent to adding s to itself n times

(2)(7)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
10

ith item of s, origin 0

(3)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
11

slice of s from i to j

(3)(4)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
12

slice of s from i to j with step k

(3)(5)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

length of s

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
14

smallest item of s

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
15

largest item of s

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
16

index of the first occurrence of x in s (at or after index i and before index j)

(8)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
17

total number of occurrences of x in s

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 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 or a is encountered (or when the index drops below zero)

ghi chú

  1. While the 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    98 and 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    99 operations are used only for simple containment testing in the general case, some specialised sequences (such as , and ) also use them for subsequence testing

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    4

  2. Values of n less than 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42 are treated as 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42 (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

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    5

    What has happened is that 

    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    27 is a one-element list containing an empty list, so all three elements of 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    28 are references to this single empty list. Modifying any of the elements of 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    29 modifies this single list. You can create a list of different lists this way

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    6

    Further explanation is available in the FAQ entry

  3. If i or j is negative, the index is relative to the end of sequence s. 

    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    30 or 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    31 is substituted. But note that 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    32 is still 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42

  4. The slice of s from i to j is defined as the sequence of items with index k such that 

    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    34. If i or j is greater than 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    13, use 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    13. If i is omitted or 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    31, use 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    42. If j is omitted or 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    31, use 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    13. If i is greater than or equal to j, the slice is empty

  5. The slice of s from i to j with step k is defined as the sequence of items with index 

    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    41 such that 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    42. In other words, the indices are 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    43, 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    44, 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    45, 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    46 and so on, stopping when j is reached (but never including j). When k is positive, i and j are reduced to 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    13 if they are greater. When k is negative, i and j are reduced to 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    48 if they are greater. If i or j are omitted or 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    31, they become “end” values (which end depends on the sign of k). Lưu ý, k không thể bằng 0. If k is 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    31, it is treated like 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    55

  6. 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 objects, you can build a list and use at the end or else write to an instance and retrieve its value when complete

    • if concatenating objects, you can similarly use or , or you can do in-place concatenation with a object. objects are mutable and have an efficient overallocation mechanism

    • if concatenating objects, extend a instead

    • for other types, investigate the relevant class documentation

  7. Some sequence types (such as ) only support item sequences that follow specific patterns, and hence don’t support sequence concatenation or repetition

  8. >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    63 raises when x is not found in s. Not all implementations support passing the additional arguments i and j. Các đối số này cho phép tìm kiếm hiệu quả các phần phụ của chuỗi. Passing the extra arguments is roughly equivalent to using 
    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    65, 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

Immutable Sequence Types

The only operation that immutable sequence types generally implement that is not also implemented by mutable sequence types is support for the built-in

This support allows immutable sequences, such as instances, to be used as keys and stored in and instances

Attempting to hash an immutable sequence that contains unhashable values will result in

Mutable Sequence Types

The operations in the following table are defined on mutable sequence types. The ABC is provided to make it easier to correctly implement these operations on custom sequence types

In the table s is an instance of a mutable sequence type, t is any iterable object and x is an arbitrary object that meets any type and value restrictions imposed by s (for example, only accepts integers that meet the value restriction 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
74)

Hoạt động

Kết quả

ghi chú

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
75

item i of s is replaced by x

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
76

slice of s from i to j is replaced by the contents of the iterable t

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
77

same as 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
78

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
79

the elements of 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
12 are replaced by those of t

(1)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
81

removes the elements of 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
12 from the list

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
83

appends x to the end of the sequence (same as 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
84)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
85

removes all items from s (same as 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
86)

(5)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
87

creates a shallow copy of s (same as 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
88)

(5)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
89 or 
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
90

extends s with the contents of t (for the most part the same as 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
91)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
92

updates s with its contents repeated n times

(6)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
93

inserts x into s at the index given by i (same as 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
94)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
95 or 
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
96

retrieves the item at i and also removes it from s

(2)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
97

remove the first item from s where 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
10 is equal to x

(3)

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
99

reverses the items of s in place

(4)

ghi chú

  1. t must have the same length as the slice it is replacing

  2. The optional argument i defaults to 

    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    41, so that by default the last item is removed and returned

  3. >>> (65).to_bytes()
b'A'
    01 raises when x is not found in s

  4. The 

    >>> (65).to_bytes()
b'A'
    03 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

  5. >>> (65).to_bytes()
b'A'
    04 và 
    >>> (65).to_bytes()
b'A'
    05 được bao gồm để thống nhất với giao diện của vùng chứa có thể thay đổi không hỗ trợ thao tác cắt (chẳng hạn như và ). 
    >>> (65).to_bytes()
b'A'
    05 is not part of the ABC, but most concrete mutable sequence classes provide it

    New in version 3. 3. 

    >>> (65).to_bytes()
b'A'
    04 and 
    >>> (65).to_bytes()
b'A'
    05 methods.

  6. The value n is an integer, or an object implementing . Zero and negative values of n clear the sequence. Items in the sequence are not copied; they are referenced multiple times, as explained for 

    >>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
    08 under

Lists

Lists are mutable sequences, typically used to store collections of homogeneous items (where the precise degree of similarity will vary by application)

class list([iterable])

Lists may be constructed in several ways

  • Using a pair of square brackets to denote the empty list. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    49

  • Using square brackets, separating items with commas. 

    >>> (65).to_bytes()
b'A'
    15, 
    >>> (65).to_bytes()
b'A'
    16

  • Using a list comprehension. 

    >>> (65).to_bytes()
b'A'
    17

  • Using the type constructor. 

    >>> (65).to_bytes()
b'A'
    18 or 
    >>> (65).to_bytes()
b'A'
    19

The constructor builds a list whose items are the same and in the same order as iterable’s items. 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 

>>> (65).to_bytes()
b'A'
20. For example, 
>>> (65).to_bytes()
b'A'
21 returns 
>>> (65).to_bytes()
b'A'
22 and 
>>> (65).to_bytes()
b'A'
23 returns 
>>> (65).to_bytes()
b'A'
24. If no argument is given, the constructor creates a new empty list, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
49

Many other operations also produce lists, including the built-in

Lists implement all of the and sequence operations. Lists also provide the following additional method

sort(* , key=None , reverse=False)

This method sorts the list in place, using only 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
74 comparisons between items. 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)

accepts two arguments that can only be passed by keyword ()

key specifies a function of one argument that is used to extract a comparison key from each list element (for example, 

>>> (65).to_bytes()
b'A'
29). The key corresponding to each item in the list is calculated once and then used for the entire sorting process. The default value of 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31 means that list items are sorted directly without calculating a separate key value

The utility is available to convert a 2. x style cmp function to a key function

reverse is a boolean value. If set to 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56, 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 to explicitly request a new sorted list instance)

The 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

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 if it can detect that the list has been mutated during a sort

Tuples

Tuples are immutable sequences, typically used to store collections of heterogeneous data (such as the 2-tuples produced by the built-in). Tuples are also used for cases where an immutable sequence of homogeneous data is needed (such as allowing storage in a or instance)

class tuple([iterable])

Tuples may be constructed in a number of ways

  • Using a pair of parentheses to denote the empty tuple. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    48

  • Using a trailing comma for a singleton tuple. 

    >>> (65).to_bytes()
b'A'
    40 or 
    >>> (65).to_bytes()
b'A'
    41

  • Tách các mục bằng dấu phẩy. 

    >>> (65).to_bytes()
b'A'
    42 or 
    >>> (65).to_bytes()
b'A'
    43

  • Using the built-in. 

    >>> (65).to_bytes()
b'A'
    44 or 
    >>> (65).to_bytes()
b'A'
    46

The constructor builds a tuple whose items are the same and in the same order as iterable’s items. iterable may be either a sequence, a container that supports iteration, or an iterator object. If iterable is already a tuple, it is returned unchanged. For example, 

>>> (65).to_bytes()
b'A'
47 returns 
>>> (65).to_bytes()
b'A'
48 and 
>>> (65).to_bytes()
b'A'
49 returns 
>>> (65).to_bytes()
b'A'
50. If no argument is given, the constructor creates a new empty tuple, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
48

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, 

>>> (65).to_bytes()
b'A'
52 is a function call with three arguments, while 
>>> (65).to_bytes()
b'A'
53 is a function call with a 3-tuple as the sole argument

Tuples implement all of the sequence operations

For heterogeneous collections of data where access by name is clearer than access by index, may be a more appropriate choice than a simple tuple object

Ranges

The type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in loops

class range(stop)class range(start , stop[ , step])

The arguments to the range constructor must be integers (either built-in or any object that implements the special method). Nếu đối số bước bị bỏ qua, nó sẽ mặc định là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
55. If the start argument is omitted, it defaults to 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
42. If step is zero, is raised

For a positive step, the contents of a range 

>>> (65).to_bytes()
b'A'
62 are determined by the formula 
>>> (65).to_bytes()
b'A'
63 where 
>>> (65).to_bytes()
b'A'
64 and 
>>> (65).to_bytes()
b'A'
65

For a negative step, the contents of the range are still determined by the formula 

>>> (65).to_bytes()
b'A'
63, but the constraints are 
>>> (65).to_bytes()
b'A'
64 and 
>>> (65).to_bytes()
b'A'
68

A range object will be empty if 

>>> (65).to_bytes()
b'A'
69 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

Phạm vi chứa giá trị tuyệt đối lớn hơn giá trị cho phép nhưng một số tính năng (chẳng hạn như ) có thể tăng

Ví dụ phạm vi

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
7

Phạm vi thực hiện tất cả các thao tác trình tự ngoại trừ phép nối và phép lặp (do thực tế là các đối tượng phạm vi chỉ có thể biểu diễn các trình tự tuân theo một mẫu nghiêm ngặt và phép lặp và phép nối thường sẽ vi phạm mẫu đó)

start

The value of the start parameter (or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
42 if the parameter was not supplied)

stop

The value of the stop parameter

step

The value of the step parameter (or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
55 if the parameter was not supplied)

The advantage of the type over a regular or is that a object will always take the same (small) amount of memory, no matter the size of the range it represents (as it only stores the 

>>> (65).to_bytes()
b'A'
79, 
>>> (65).to_bytes()
b'A'
80 and 
>>> (65).to_bytes()
b'A'
81 values, calculating individual items and subranges as needed)

Range objects implement the ABC, and provide features such as containment tests, element index lookup, slicing and support for negative indices (see )

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
8

Testing range objects for equality with 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
78 and 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
79 compares them as sequences. That is, two range objects are considered equal if they represent the same sequence of values. (Note that two range objects that compare equal might have different , and attributes, for example 
>>> (65).to_bytes()
b'A'
88 or 
>>> (65).to_bytes()
b'A'
89. )

Changed in version 3. 2. Implement the Sequence ABC. Support slicing and negative indices. Test objects for membership in constant time instead of iterating through all items.

Changed in version 3. 3. Define ‘==’ and ‘. =’ to compare range objects based on the sequence of values they define (instead of comparing based on object identity).

New in version 3. 3. The , and attributes.

See also

  • The linspace recipe shows how to implement a lazy version of range suitable for floating point applications

Text Sequence Type —

Textual data in Python is handled with objects, or strings. Các chuỗi là bất biến của các điểm mã Unicode. String literals are written in a variety of ways

  • Single quotes. 

    >>> (65).to_bytes()
b'A'
    96

  • Double quotes. 

    >>> (65).to_bytes()
b'A'
    97

  • Triple quoted. 

    >>> (65).to_bytes()
b'A'
    98, 
    >>> (65).to_bytes()
b'A'
    99

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. That is, 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
00

See for more about the various forms of string literal, including supported escape sequences, and the 

>>> (65).to_bytes()
b'A'
62 (“raw”) prefix that disables most escape sequence processing

Strings may also be created from other objects using the constructor

Since there is no separate “character” type, indexing a string produces strings of length 1. That is, for a non-empty string s, 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
03

There is also no mutable string type, but or can be used to efficiently construct strings from multiple fragments

Changed in version 3. 3. For backwards compatibility with the Python 2 series, the 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
06 prefix is once again permitted on string literals. It has no effect on the meaning of string literals and cannot be combined with the 
>>> (65).to_bytes()
b'A'
62 prefix.

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

Return a version of object. If object is not provided, returns the empty string. Otherwise, the behavior of 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
33 depends on whether encoding or errors is given, as follows

If neither encoding nor errors is given, 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
09 returns , which is the “informal” or nicely printable string representation of object. For string objects, this is the string itself. If object does not have a method, then falls back to returning

If at least one of encoding or errors is given, object should be a (e. g. or ). In this case, if object is a (or ) object, then 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
18 is equivalent to . Otherwise, the bytes object underlying the buffer object is obtained before calling . See and for information on buffer objects

Passing a object to without the encoding or errors arguments falls under the first case of returning the informal string representation (see also the command-line option to Python). For example

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
9

For more information on the 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
22 class and its methods, see and the section below. To output formatted strings, see the and sections. In addition, see the section

String Methods

Strings implement all of the 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 , and ) and the other based on C 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
26 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 ()

The section of the standard library covers a number of other modules that provide various text related utilities (including regular expression support in the module)

str. capitalize()

Return a copy of the string with its first character capitalized and the rest lowercased

Changed in version 3. 8. The first character is now put into titlecase rather than uppercase. This means that characters like digraphs will only have their first letter capitalized, instead of the full character.

str. casefold()

Return a casefolded copy of the string. Casefolded strings may be used for caseless matching

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 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
28 is equivalent to 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
29. Vì nó đã là chữ thường, nên sẽ không làm gì với 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
28;

The casefolding algorithm is described in section 3. 13 of the Unicode Standard

New in version 3. 3

str. center(width[ , fillchar])

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 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

str. count(sub[ , start[ , end]])

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

str. encode(encoding='utf-8' , errors='strict')

Trả lại chuỗi được mã hóa thành

mã hóa mặc định thành 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
36;

errors controls how encoding errors are handled. If 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
37 (the default), a exception is raised. Các giá trị có thể khác là 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
39, 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
40, 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
41, 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
42 và bất kỳ tên nào khác được đăng ký qua. See for details

Vì lý do hiệu suất, giá trị của lỗi không được kiểm tra tính hợp lệ trừ khi thực sự xảy ra lỗi mã hóa, được bật hoặc a được sử dụng

Đã thay đổi trong phiên bản 3. 1. Đã thêm hỗ trợ cho đối số từ khóa.

Đã thay đổi trong phiên bản 3. 9. Giá trị của đối số lỗi hiện được kiểm tra trong và trong.

str. endswith(hậu tố[ , start[, end]])

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu chuỗi kết thúc bằng hậu tố đã chỉ định, nếu không thì trả về 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. hậu tố cũng có thể là một bộ hậu tố cần tìm. Với bắt đầu tùy chọn, bắt đầu kiểm tra tại vị trí đó. Với đầu cuối tùy chọn, dừng so sánh tại vị trí đó

str. tab mở rộng(kích thước tab=8)

Trả về một bản sao của chuỗi trong đó tất cả các ký tự tab được thay thế bằng một hoặc nhiều dấu cách, tùy thuộc vào cột hiện tại và kích thước tab đã cho. 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. If the character is a tab (

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
46), one or more space characters are inserted in the result until the current column is equal to the next tab position. (The tab character itself is not copied. ) If the character is a newline (
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
47) or return (
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
48), it is copied and the current column is reset to zero. Any other character is copied unchanged and the current column is incremented by one regardless of how the character is represented when printed

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
0

str. find(sub[ , start[ , end]])

Return the lowest index in the string where substring sub is found within the slice 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
49. Optional arguments start and end are interpreted as in slice notation. Return 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
41 if sub is not found

Ghi chú

The 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 operator

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
1

str. format(*args , **kwargs)

Perform a string formatting operation. The string on which this method is called can contain literal text or replacement fields delimited by braces 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
50. 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

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
2

See for a description of the various formatting options that can be specified in format strings

Ghi chú

When formatting a number (, , , and subclasses) with the 

def bit_count(self):
    return bin(self).count("1")
51 type (ex. 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
59), the function temporarily sets the 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
60 locale to the 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
61 locale to decode 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
62 and 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
63 fields of 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
64 if they are non-ASCII or longer than 1 byte, and the 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
61 locale is different than the 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
60 locale. This temporary change affects other threads

Changed in version 3. 7. When formatting a number with the 

def bit_count(self):
    return bin(self).count("1")
51 type, the function sets temporarily the 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
60 locale to the 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
61 locale in some cases.

str. format_map(mapping)

Similar to 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
70, except that 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
71 is used directly and not copied to a . This is useful if for example 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
71 is a dict subclass

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
3

New in version 3. 2

str. index(sub[ , start[ , end]])

Like , but raise when the substring is not found

str. isalnum()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all characters in the string are alphanumeric and there is at least one character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise. A character 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
78 is alphanumeric if one of the following returns 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56. 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
80, 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
81, 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
82, or 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
83

str. isalpha()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all characters in the string are alphabetic and there is at least one character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise. Alphabetic characters are those characters defined in the Unicode character database as “Letter”, i. e. , those with general category property being one of “Lm”, “Lt”, “Lu”, “Ll”, or “Lo”. Note that this is different from the “Alphabetic” property defined in the Unicode Standard

str. isascii()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if the string is empty or all characters in the string are ASCII, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise. ASCII characters have code points in the range U+0000-U+007F

New in version 3. 7

str. isdecimal()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all characters in the string are decimal characters and there is at least one character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise. Decimal characters are those that can be used to form numbers in base 10, e. g. U+0660, ARABIC-INDIC DIGIT ZERO. Formally a decimal character is a character in the Unicode General Category “Nd”

str. isdigit()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all characters in the string are digits and there is at least one character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 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. Formally, a digit is a character that has the property value Numeric_Type=Digit or Numeric_Type=Decimal

str. mã định danh()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if the string is a valid identifier according to the language definition, section

Call to test whether string 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
94 is a reserved identifier, such as and

Example

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
4

str. islower()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all cased characters in the string are lowercase and there is at least one cased character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise

str. isnumeric()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all characters in the string are numeric characters, and there is at least one character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise. Numeric characters include digit characters, and all characters that have the Unicode numeric value property, e. g. U+2155, VULGAR FRACTION ONE FIFTH. Formally, numeric characters are those with the property value Numeric_Type=Digit, Numeric_Type=Decimal or Numeric_Type=Numeric

str. isprintable()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all characters in the string are printable or the string is empty, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise. Nonprintable characters are those characters defined in the Unicode character database as “Other” or “Separator”, excepting the ASCII space (0x20) which is considered printable. (Note that printable characters in this context are those which should not be escaped when is invoked on a string. It has no bearing on the handling of strings written to or . )

str. isspace()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if there are only whitespace characters in the string and there is at least one character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise

A character is whitespace if in the Unicode character database (see ), either its general category is 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
09 (“Separator, space”), or its bidirectional class is one of 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
10, 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
11, or 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
12

str. istitle()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu chuỗi là một chuỗi có tiêu đề và có ít nhất một ký tự, ví dụ: các ký tự chữ hoa chỉ có thể theo sau các ký tự không có chữ hoa và các ký tự chữ thường chỉ theo sau các ký tự có chữ hoa. Return 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise

str. isupper()

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if all cased characters in the string are uppercase and there is at least one cased character, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 otherwise

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
5

str. join(iterable)

Trả về một chuỗi là chuỗi nối của các chuỗi trong iterable. A sẽ được nâng lên nếu có bất kỳ giá trị không phải chuỗi nào có thể lặp lại, bao gồm cả các đối tượng. The separator between elements is the string providing this method

str. ljust(width[ , fillchar])

Return the string left justified 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 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

str. lower()

Return a copy of the string with all the cased characters converted to lowercase

The lowercasing algorithm used is described in section 3. 13 of the Unicode Standard

str. lstrip([chars])

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 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, the chars argument defaults to removing whitespace. The chars argument is not a prefix; rather, all combinations of its values are stripped

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
6

See for a method that will remove a single prefix string rather than all of a set of characters. For example

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
7

tĩnh str. maketrans(x[ , y[ , z]])

This static method returns a translation table usable for

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 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31. 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 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31 in the result

str. partition(sep)

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

str. removeprefix(prefix , /)

If the string starts with the prefix string, return 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
25. Otherwise, return a copy of the original string

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
8

New in version 3. 9

str. removesuffix(suffix , /)

If the string ends with the suffix string and that suffix is not empty, return 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
26. Otherwise, return a copy of the original string

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
9

New in version 3. 9

str. replace(old , new[ , count])

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

str. rfind(sub[ , start[ , end]])

Return the highest index in the string where substring sub is found, such that sub is contained within 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
49. Optional arguments start and end are interpreted as in slice notation. Return 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
41 on failure

str. rindex(sub[ , start[ , end]])

Like but raises when the substring sub is not found

str. rjust(width[ , fillchar])

Return the string right justified 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 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

str. rpartition(sep)

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

str. rsplit(sep=None , maxsplit=- 1)

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 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, any whitespace string is a separator. Except for splitting from the right, behaves like which is described in detail below

str. rstrip([chars])

Return a copy of the string with trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, the chars argument defaults to removing whitespace. The chars argument is not a suffix; rather, all combinations of its values are stripped

def bit_count(self):
    return bin(self).count("1")
0

See for a method that will remove a single suffix string rather than all of a set of characters. For example

def bit_count(self):
    return bin(self).count("1")
1

str. split(sep=None , maxsplit=- 1)

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 (thus, the list will have at most 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
37 elements). If maxsplit is not specified or 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
41, then there is no limit on the number of splits (all possible splits are made)

If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
39 returns 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
40). The sep argument may consist of multiple characters (for example, 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
41 returns 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
42). Splitting an empty string with a specified separator returns 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
43

For example

def bit_count(self):
    return bin(self).count("1")
2

If sep is not specified or is 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, a different splitting algorithm is applied. runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31 separator returns 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
49

For example

def bit_count(self):
    return bin(self).count("1")
3

str. splitlines(keepends=False)

Return a list of the lines in the string, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true

This method splits on the following line boundaries. In particular, the boundaries are a superset of

Representation

Description

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
47

Nguồn cấp dữ liệu dòng

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
48

Vận chuyển trở lại

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
49

Trả lại vận chuyển + Nguồn cấp dữ liệu

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
50 hoặc 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
51

Lập bảng dòng

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
52 or 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
53

Thức ăn dạng

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
54

File Separator

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
55

Group Separator

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
56

Dấu tách bản ghi

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
57

Next Line (C1 Control Code)

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
58

Line Separator

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
59

Paragraph Separator

Changed in version 3. 2. 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
50 and 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
52 added to list of line boundaries.

For example

def bit_count(self):
    return bin(self).count("1")
4

Unlike when a delimiter string sep is given, this method returns an empty list for the empty string, and a terminal line break does not result in an extra line

def bit_count(self):
    return bin(self).count("1")
5

For comparison, 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
63 gives

def bit_count(self):
    return bin(self).count("1")
6

str. startswith(prefix[ , start[ , end]])

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if string starts with the prefix, otherwise return 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. prefix can also be a tuple of prefixes to look for. Với bắt đầu tùy chọn, chuỗi kiểm tra bắt đầu ở vị trí đó. With optional end, stop comparing string at that position

str. strip([chars])

Return a copy of the string with the leading and trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, the chars argument defaults to removing whitespace. The chars argument is not a prefix or suffix; rather, all combinations of its values are stripped

def bit_count(self):
    return bin(self).count("1")
7

The outermost leading and trailing chars argument values are stripped from the string. Characters are removed from the leading end until reaching a string character that is not contained in the set of characters in chars. A similar action takes place on the trailing end. For example

def bit_count(self):
    return bin(self).count("1")
8

str. swapcase()

Return a copy of the string with uppercase characters converted to lowercase and vice versa. Note that it is not necessarily true that 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
67

str. title()

Return a titlecased version of the string where words start with an uppercase character and the remaining characters are lowercase

For example

def bit_count(self):
    return bin(self).count("1")
9

The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries, which may not be the desired result

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
0

The function does not have this problem, as it splits words on spaces only

Alternatively, a workaround for apostrophes can be constructed using regular expressions

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
1

str. translate(table)

Return a copy of the string in which each character has been mapped through the given translation table. The table must be an object that implements indexing via 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
69, typically a or . When indexed by a Unicode ordinal (an integer), the table object can do any of the following. return a Unicode ordinal or a string, to map the character to one or more other characters; return 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, to delete the character from the return string; or raise a exception, to map the character to itself

You can use to create a translation map from character-to-character mappings in different formats

See also the module for a more flexible approach to custom character mappings

str. upper()

Return a copy of the string with all the cased characters converted to uppercase. Note that 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
74 might be 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 if 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
94 contains uncased characters or if the Unicode category of the resulting character(s) is not “Lu” (Letter, uppercase), but e. g. “Lt” (Letter, titlecase)

Thuật toán viết hoa được sử dụng được mô tả trong phần 3. 13 of the Unicode Standard

str. zfill(width)

Return a copy of the string left filled with ASCII 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
77 digits to make a string of length width. A leading sign prefix (
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
78/
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
79) is handled by inserting the padding after the sign character rather than before. The original string is returned if width is less than or equal to 
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

For example

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
2

def to_bytes(n, length=1, byteorder='big', signed=False): if byteorder == 'little': order = range(length) elif byteorder == 'big': order = reversed(range(length)) else: raise ValueError("byteorder must be either 'little' or 'big'") return bytes((n >> i*8) & 0xff for i in order) 26-style String Formatting

Ghi chú

The formatting operations described here exhibit a variety of quirks that lead to a number of common errors (such as failing to display tuples and dictionaries correctly). Using the newer , the interface, or may help avoid these errors. Each of these alternatives provides their own trade-offs and benefits of simplicity, flexibility, and/or extensibility

String objects have one unique built-in operation. the 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
83 operator (modulo). This is also known as the string formatting or interpolation operator. Cho trước 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
84 (trong đó định dạng là một chuỗi), thông số kỹ thuật chuyển đổi của 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
83 ở định dạng được thay thế bằng 0 hoặc nhiều phần tử giá trị. The effect is similar to using the 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
86 in the C language

If format requires a single argument, values may be a single non-tuple object. Otherwise, values must be a tuple with exactly the number of items specified by the format string, or a single mapping object (for example, a dictionary)

A conversion specifier contains two or more characters and has the following components, which must occur in this order

  1. The 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    87 character, which marks the start of the specifier

  2. Mapping key (optional), consisting of a parenthesised sequence of characters (for example, 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    88)

  3. Conversion flags (optional), which affect the result of some conversion types

  4. Minimum field width (optional). If specified as an 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    89 (asterisk), the actual width is read from the next element of the tuple in values, and the object to convert comes after the minimum field width and optional precision

  5. Precision (optional), given as a 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    90 (dot) followed by the precision. If specified as 
    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    89 (an asterisk), the actual precision is read from the next element of the tuple in values, and the value to convert comes after the precision

  6. Length modifier (optional)

  7. Conversion type

When the right argument is a dictionary (or other mapping type), then the formats in the string must include a parenthesised mapping key into that dictionary inserted immediately after the 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
87 character. The mapping key selects the value to be formatted from the mapping. For example

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
3

In this case no 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
00 specifiers may occur in a format (since they require a sequential parameter list)

The conversion flag characters are

Flag

Meaning

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
94

The value conversion will use the “alternate form” (where defined below)

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
77

The conversion will be zero padded for numeric values

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
79

The converted value is left adjusted (overrides the 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
77 conversion if both are given)

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
98

(a space) A blank should be left before a positive number (or empty string) produced by a signed conversion

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
78

A sign character (

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
78 or 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
79) will precede the conversion (overrides a “space” flag)

A length modifier (

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
02, 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
03, or 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
04) may be present, but is ignored as it is not necessary for Python – so e. g. 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
05 is identical to 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
06

The conversion types are

Conversion

Meaning

ghi chú

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
07

Signed integer decimal

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
08

Signed integer decimal

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
09

Signed octal value

(1)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
10

Loại lỗi thời – nó giống hệt với 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
07

(6)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
12

Signed hexadecimal (lowercase)

(2)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
13

Signed hexadecimal (uppercase)

(2)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
14

Floating point exponential format (lowercase)

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
15

Floating point exponential format (uppercase)

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
16

Floating point decimal format

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
17

Floating point decimal format

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
18

Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise

(4)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
19

Định dạng dấu phẩy động. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise

(4)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
20

Single character (accepts integer or single character string)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
21

String (converts any Python object using )

(5)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
23

String (converts any Python object using )

(5)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
25

String (converts any Python object using )

(5)

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
87

No argument is converted, results in a 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
87 character in the result

ghi chú

  1. The alternate form causes a leading octal specifier (

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    29) to be inserted before the first digit

  2. The alternate form causes a leading 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    30 or 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    31 (depending on whether the 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    12 or 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    13 format was used) to be inserted before the first digit

  3. The alternate form causes the result to always contain a decimal point, even if no digits follow it

    The precision determines the number of digits after the decimal point and defaults to 6

  4. The alternate form causes the result to always contain a decimal point, and trailing zeroes are not removed as they would otherwise be

    The precision determines the number of significant digits before and after the decimal point and defaults to 6

  5. If precision is 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    34, the output is truncated to 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    34 characters

  6. See PEP 237

Since Python strings have an explicit length, 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
36 conversions do not assume that 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
37 is the end of the string

Changed in version 3. 1. 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
38 conversions for numbers whose absolute value is over 1e50 are no longer replaced by 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
39 conversions.

Binary Sequence Types — , ,

The core built-in types for manipulating binary data are and . They are supported by which uses the to access the memory of other binary objects without needing to make a copy

The module supports efficient storage of basic data types like 32-bit integers and IEEE754 double-precision floating values

Bytes Objects

Bytes objects are immutable sequences of single bytes. Since many major binary protocols are based on the ASCII text encoding, bytes objects offer several methods that are only valid when working with ASCII compatible data and are closely related to string objects in a variety of other ways

class bytes([source[ , encoding[ , errors]]])

Firstly, the syntax for bytes literals is largely the same as that for string literals, except that a 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
47 prefix is added

  • Single quotes. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    48

  • Double quotes. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    49

  • Triple quoted. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    50, 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    51

Only ASCII characters are permitted in bytes literals (regardless of the declared source code encoding). Any binary values over 127 must be entered into bytes literals using the appropriate escape sequence

As with string literals, bytes literals may also use a 

>>> (65).to_bytes()
b'A'
62 prefix to disable processing of escape sequences. See for more about the various forms of bytes literal, including supported escape sequences

While bytes literals and representations are based on ASCII text, bytes objects actually behave like immutable sequences of integers, with each value in the sequence restricted such that 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
53 (attempts to violate this restriction will trigger ). This is done deliberately to emphasise that while many binary formats include ASCII based elements and can be usefully manipulated with some text-oriented algorithms, this is not generally the case for arbitrary binary data (blindly applying text processing algorithms to binary data formats that are not ASCII compatible will usually lead to data corruption)

In addition to the literal forms, bytes objects can be created in a number of other ways

  • A zero-filled bytes object of a specified length. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    55

  • From an iterable of integers. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    56

  • Copying existing binary data via the buffer protocol. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    57

Also see the built-in

Since 2 hexadecimal digits correspond precisely to a single byte, hexadecimal numbers are a commonly used format for describing binary data. Accordingly, the bytes type has an additional class method to read data in that format

classmethod fromhex(string)

This class method returns a bytes object, decoding the given string object. The string must contain two hexadecimal digits per byte, with ASCII whitespace being ignored

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
4

Changed in version 3. 7. now skips all ASCII whitespace in the string, not just spaces.

A reverse conversion function exists to transform a bytes object into its hexadecimal representation

hex([sep[ , bytes_per_sep]])

Return a string object containing two hexadecimal digits for each byte in the instance

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
5

If you want to make the hex string easier to read, you can specify a single character separator sep parameter to include in the output. By default, this separator will be included between each byte. A second optional bytes_per_sep parameter controls the spacing. Positive values calculate the separator position from the right, negative values from the left

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
6

New in version 3. 5

Changed in version 3. 8. now supports optional sep and bytes_per_sep parameters to insert separators between bytes in the hex output.

Since bytes objects are sequences of integers (akin to a tuple), for a bytes object b, 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
61 will be an integer, while 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
62 will be a bytes object of length 1. (This contrasts with text strings, where both indexing and slicing will produce a string of length 1)

The representation of bytes objects uses the literal format (

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
63) since it is often more useful than e. g. 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
64. You can always convert a bytes object into a list of integers using 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
65

Bytearray Objects

objects are a mutable counterpart to objects

class bytearray([source[ , encoding[ , errors]]])

There is no dedicated literal syntax for bytearray objects, instead they are always created by calling the constructor

  • Creating an empty instance. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    68

  • Creating a zero-filled instance with a given length. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    69

  • From an iterable of integers. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    70

  • Copying existing binary data via the buffer protocol. 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    71

Vì các đối tượng mảng phụ có thể thay đổi, nên chúng hỗ trợ các hoạt động tuần tự ngoài các hoạt động byte và mảng phụ phổ biến được mô tả trong

Also see the built-in

Vì 2 chữ số thập lục phân tương ứng chính xác với một byte đơn, số thập lục phân là định dạng thường được sử dụng để mô tả dữ liệu nhị phân. Accordingly, the bytearray type has an additional class method to read data in that format

classmethod fromhex(string)

This class method returns bytearray object, decoding the given string object. The string must contain two hexadecimal digits per byte, with ASCII whitespace being ignored

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
7

Changed in version 3. 7. now skips all ASCII whitespace in the string, not just spaces.

A reverse conversion function exists to transform a bytearray object into its hexadecimal representation

hex([sep[ , bytes_per_sep]])

Return a string object containing two hexadecimal digits for each byte in the instance

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
8

New in version 3. 5

Changed in version 3. 8. Similar to , now supports optional sep and bytes_per_sep parameters to insert separators between bytes in the hex output.

Since bytearray objects are sequences of integers (akin to a list), for a bytearray object b, 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
61 will be an integer, while 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
62 will be a bytearray object of length 1. (This contrasts with text strings, where both indexing and slicing will produce a string of length 1)

Việc biểu diễn các đối tượng bytearray sử dụng định dạng byte bằng chữ (

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
78) vì nó thường hữu ích hơn e. g. 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
79. You can always convert a bytearray object into a list of integers using 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
65

Bytes and Bytearray Operations

Both bytes and bytearray objects support the sequence operations. They interoperate not just with operands of the same type, but with any . Due to this flexibility, they can be freely mixed in operations without causing errors. However, the return type of the result may depend on the order of operands

Ghi chú

The methods on bytes and bytearray objects don’t accept strings as their arguments, just as the methods on strings don’t accept bytes as their arguments. For example, you have to write

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
9

and

>>> (65).to_bytes()
b'A'
0

Some bytes and bytearray operations assume the use of ASCII compatible binary formats, and hence should be avoided when working with arbitrary binary data. These restrictions are covered below

Ghi chú

Using these ASCII based operations to manipulate binary data that is not stored in an ASCII based format may lead to data corruption

The following methods on bytes and bytearray objects can be used with arbitrary binary data

bytes. count(sub[ , start[ , end]])bytearray. count(sub[ , start[ , end]])

Return the number of non-overlapping occurrences of subsequence sub in the range [start, end]. Optional arguments start and end are interpreted as in slice notation

The subsequence to search for may be any or an integer in the range 0 to 255

If sub is empty, returns the number of empty slices between characters which is the length of the bytes object plus one

Changed in version 3. 3. Also accept an integer in the range 0 to 255 as the subsequence.

bytes. removeprefix(prefix , /)bytearray. removeprefix(prefix , /)

If the binary data starts with the prefix string, return 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
81. Otherwise, return a copy of the original binary data

>>> (65).to_bytes()
b'A'
1

The prefix may be any

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

New in version 3. 9

bytes. removesuffix(suffix , /)bytearray. removesuffix(suffix , /)

If the binary data ends with the suffix string and that suffix is not empty, return 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
82. Otherwise, return a copy of the original binary data

>>> (65).to_bytes()
b'A'
2

The suffix may be any

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

New in version 3. 9

bytes. decode(encoding='utf-8' , errors='strict')bytearray. decode(encoding='utf-8' , errors='strict')

Return the bytes decoded to a

mã hóa mặc định thành 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
36;

errors controls how decoding errors are handled. If 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
37 (the default), a exception is raised. Other possible values are 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
39, 
def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
40, and any other name registered via . See for details

For performance reasons, the value of errors is not checked for validity unless a decoding error actually occurs, is enabled or a is used

Ghi chú

Passing the encoding argument to allows decoding any directly, without needing to make a temporary 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
23 or 
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
24 object

Đã thay đổi trong phiên bản 3. 1. Đã thêm hỗ trợ cho đối số từ khóa.

Đã thay đổi trong phiên bản 3. 9. Giá trị của đối số lỗi hiện được kiểm tra trong và trong.

bytes. endswith(suffix[ , start[ , end]])bytearray. endswith(suffix[ , start[ , end]])

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if the binary data ends with the specified suffix, otherwise return 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. suffix can also be a tuple of suffixes to look for. With optional start, test beginning at that position. Với đầu cuối tùy chọn, dừng so sánh tại vị trí đó

The suffix(es) to search for may be any

bytes. find(sub[ , start[ , end]])bytearray. find(sub[ , start[ , end]])

Return the lowest index in the data where the subsequence sub is found, such that sub is contained in the slice 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
49. Optional arguments start and end are interpreted as in slice notation. Return 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
41 if sub is not found

The subsequence to search for may be any or an integer in the range 0 to 255

Ghi chú

The 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 operator

>>> (65).to_bytes()
b'A'
3

Changed in version 3. 3. Also accept an integer in the range 0 to 255 as the subsequence.

bytes. index(sub[ , start[ , end]])bytearray. index(sub[ , start[ , end]])

Like , but raise when the subsequence is not found

The subsequence to search for may be any or an integer in the range 0 to 255

Changed in version 3. 3. Also accept an integer in the range 0 to 255 as the subsequence.

bytes. join(iterable)bytearray. join(iterable)

Return a bytes or bytearray object which is the concatenation of the binary data sequences in iterable. A will be raised if there are any values in iterable that are not , including objects. The separator between elements is the contents of the bytes or bytearray object providing this method

static bytes. maketrans(from , to)static bytearray. maketrans(from , to)

This static method returns a translation table usable for that will map each character in from into the character at the same position in to; from and to must both be and have the same length

Mới trong phiên bản 3. 1

bytes. partition(sep)bytearray. partition(sep)

Split the sequence at the first occurrence of sep, and return a 3-tuple containing the part before the separator, the separator itself or its bytearray copy, and the part after the separator. If the separator is not found, return a 3-tuple containing a copy of the original sequence, followed by two empty bytes or bytearray objects

The separator to search for may be any

bytes. replace(old , new[ , count])bytearray. replace(old , new[ , count])

Return a copy of the sequence with all occurrences of subsequence old replaced by new. If the optional argument count is given, only the first count occurrences are replaced

The subsequence to search for and its replacement may be any

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

bytes. rfind(sub[ , start[ , end]])bytearray. rfind(sub[ , start[ , end]])

Return the highest index in the sequence where the subsequence sub is found, such that sub is contained within 

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
49. Optional arguments start and end are interpreted as in slice notation. Return 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
41 on failure

The subsequence to search for may be any or an integer in the range 0 to 255

Changed in version 3. 3. Also accept an integer in the range 0 to 255 as the subsequence.

bytes. rindex(sub[ , start[ , end]])bytearray. rindex(sub[ , start[ , end]])

Like nhưng tăng khi không tìm thấy sub nối tiếp

The subsequence to search for may be any or an integer in the range 0 to 255

Changed in version 3. 3. Also accept an integer in the range 0 to 255 as the subsequence.

byte. rpartition(sep)bytearray. rpartition(sep)

Split the sequence at the last occurrence of sep, and return a 3-tuple containing the part before the separator, the separator itself or its bytearray copy, and the part after the separator. If the separator is not found, return a 3-tuple containing two empty bytes or bytearray objects, followed by a copy of the original sequence

The separator to search for may be any

bytes. startswith(prefix[ , start[ , end]])bytearray. startswith(prefix[ , start[ , end]])

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if the binary data starts with the specified prefix, otherwise return 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. prefix can also be a tuple of prefixes to look for. Với bắt đầu tùy chọn, bắt đầu kiểm tra tại vị trí đó. With optional end, stop comparing at that position

The prefix(es) to search for may be any

bytes. translate(table , / , delete=b'')bytearray. translate(table , / , delete=b'')

Return a copy of the bytes or bytearray object where all bytes occurring in the optional argument delete are removed, and the remaining bytes have been mapped through the given translation table, which must be a bytes object of length 256

You can use the method to create a translation table

Set the table argument to 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31 for translations that only delete characters

>>> (65).to_bytes()
b'A'
4

Changed in version 3. 6. delete is now supported as a keyword argument.

The following methods on bytes and bytearray objects have default behaviours that assume the use of ASCII compatible binary formats, but can still be used with arbitrary binary data by passing appropriate arguments. Note that all of the bytearray methods in this section do not operate in place, and instead produce new objects

bytes. center(width[ , fillbyte])bytearray. center(width[ , fillbyte])

Return a copy of the object centered in a sequence of length width. Padding is done using the specified fillbyte (default is an ASCII space). For objects, the original sequence is returned if width is less than or equal to 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

bytes. ljust(width[ , fillbyte])bytearray. ljust(width[ , fillbyte])

Return a copy of the object left justified in a sequence of length width. Padding is done using the specified fillbyte (default is an ASCII space). For objects, the original sequence is returned if width is less than or equal to 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

bytes. lstrip([chars])bytearray. lstrip([chars])

Return a copy of the sequence with specified leading bytes removed. The chars argument is a binary sequence specifying the set of byte values to be removed - the name refers to the fact this method is usually used with ASCII characters. If omitted or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, the chars argument defaults to removing ASCII whitespace. The chars argument is not a prefix; rather, all combinations of its values are stripped

>>> (65).to_bytes()
b'A'
5

The binary sequence of byte values to remove may be any . See for a method that will remove a single prefix string rather than all of a set of characters. For example

>>> (65).to_bytes()
b'A'
6

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

bytes. rjust(width[ , fillbyte])bytearray. rjust(width[ , fillbyte])

Return a copy of the object right justified in a sequence of length width. Padding is done using the specified fillbyte (default is an ASCII space). For objects, the original sequence is returned if width is less than or equal to 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
13

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

bytes. rsplit(sep=None , maxsplit=- 1)bytearray. rsplit(sep=None , maxsplit=- 1)

Split the binary sequence into subsequences of the same type, 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 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, any subsequence consisting solely of ASCII whitespace is a separator. Except for splitting from the right, behaves like which is described in detail below

bytes. rstrip([chars])bytearray. rstrip([chars])

Trả về một bản sao của chuỗi đã xóa các byte theo sau được chỉ định. The chars argument is a binary sequence specifying the set of byte values to be removed - the name refers to the fact this method is usually used with ASCII characters. If omitted or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, the chars argument defaults to removing ASCII whitespace. The chars argument is not a suffix; rather, all combinations of its values are stripped

>>> (65).to_bytes()
b'A'
7

The binary sequence of byte values to remove may be any . See for a method that will remove a single suffix string rather than all of a set of characters. For example

>>> (65).to_bytes()
b'A'
8

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

bytes. split(sep=None , maxsplit=- 1)bytearray. split(sep=None , maxsplit=- 1)

Split the binary sequence into subsequences of the same type, using sep as the delimiter string. If maxsplit is given and non-negative, at most maxsplit splits are done (thus, the list will have at most 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
37 elements). If maxsplit is not specified or is 
>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
41, then there is no limit on the number of splits (all possible splits are made)

If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty subsequences (for example, 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
27 returns 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
28). The sep argument may consist of a multibyte sequence (for example, 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
29 returns 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
30). Splitting an empty sequence with a specified separator returns 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
31 or 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
32 depending on the type of object being split. The sep argument may be any

For example

>>> (65).to_bytes()
b'A'
9

If sep is not specified or is 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, a different splitting algorithm is applied. runs of consecutive ASCII whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the sequence has leading or trailing whitespace. Consequently, splitting an empty sequence or a sequence consisting solely of ASCII whitespace without a specified separator returns 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
49

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
0

bytes. strip([chars])bytearray. strip([chars])

Return a copy of the sequence with specified leading and trailing bytes removed. The chars argument is a binary sequence specifying the set of byte values to be removed - the name refers to the fact this method is usually used with ASCII characters. If omitted or 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, the chars argument defaults to removing ASCII whitespace. The chars argument is not a prefix or suffix; rather, all combinations of its values are stripped

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
1

The binary sequence of byte values to remove may be any

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

The following methods on bytes and bytearray objects assume the use of ASCII compatible binary formats and should not be applied to arbitrary binary data. Note that all of the bytearray methods in this section do not operate in place, and instead produce new objects

bytes. capitalize()bytearray. capitalize()

Trả về một bản sao của chuỗi với mỗi byte được hiểu là ký tự ASCII và byte đầu tiên được viết hoa và phần còn lại được viết thường. Các giá trị byte không phải ASCII được chuyển qua không thay đổi

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

byte. tab mở rộng(kích thước tab=8 . )bytearray.tab mở rộng(kích thước tab=8)

Trả về một bản sao của chuỗi trong đó tất cả các ký tự tab ASCII được thay thế bằng một hoặc nhiều khoảng trắng ASCII, tùy thuộc vào cột hiện tại và kích thước tab đã cho. Vị trí tab xuất hiện ở mỗi byte kích thước tab (mặc định là 8, cung cấp vị trí tab tại các cột 0, 8, 16, v.v.). Để mở rộng chuỗi, cột hiện tại được đặt thành 0 và chuỗi được kiểm tra từng byte. If the byte is an ASCII tab character (

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
36), one or more space characters are inserted in the result until the current column is equal to the next tab position. (Bản thân ký tự tab không được sao chép. ) Nếu byte hiện tại là một dòng mới ASCII (
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
37) hoặc dấu xuống dòng (
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
38), nó sẽ được sao chép và cột hiện tại được đặt lại về 0. Bất kỳ giá trị byte nào khác được sao chép không thay đổi và cột hiện tại được tăng thêm một bất kể giá trị byte được biểu thị như thế nào khi in

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
2

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

byte. isalnum()bytearray. isalnum()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu tất cả các byte trong chuỗi là ký tự ASCII theo thứ tự bảng chữ cái hoặc chữ số thập phân ASCII và chuỗi không trống, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. Các ký tự ASCII theo bảng chữ cái là các giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
41. Chữ số thập phân ASCII là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
42

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
3

byte. isalpha()bytearray. isalpha()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu tất cả các byte trong chuỗi là các ký tự bảng chữ cái ASCII và chuỗi không trống, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. Các ký tự ASCII theo bảng chữ cái là các giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
41

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
4

byte. isascii()bytearray. isascii()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu chuỗi trống hoặc tất cả các byte trong chuỗi là ASCII, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. Các byte ASCII nằm trong phạm vi 0-0x7F

New in version 3. 7

byte. isdigit()bytearray. isdigit()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu tất cả các byte trong chuỗi là chữ số thập phân ASCII và chuỗi không trống, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. Chữ số thập phân ASCII là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
42

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
5

byte. islower()bytearray. giảm tốc()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu có ít nhất một ký tự ASCII chữ thường trong chuỗi và không có ký tự ASCII chữ hoa, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
6

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
53. Các ký tự ASCII chữ hoa là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
54

byte. không gian()bytearray. không gian()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu tất cả các byte trong chuỗi là khoảng trắng ASCII và chuỗi không trống, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. Các ký tự khoảng trắng ASCII là các giá trị byte đó trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
57 (dấu cách, tab, dòng mới, xuống dòng, tab dọc, nguồn cấp biểu mẫu)

bytes. tiêu đề()bytearray. tiêu đề()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu chuỗi là chữ cái tiêu đề ASCII và chuỗi không trống, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. Xem để biết thêm chi tiết về định nghĩa của “titlecase”

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
7

byte. issupper()bytearray. ăn tối()

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu có ít nhất một ký tự ASCII chữ hoa trong chuỗi và không có ký tự ASCII chữ thường, ngược lại là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
8

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
53. Các ký tự ASCII chữ hoa là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
54

byte. hạ()bytearray. thấp hơn()

Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ hoa được chuyển đổi thành chữ thường tương ứng của chúng

For example

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)
9

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
53. Các ký tự ASCII chữ hoa là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
54

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

byte. đường phân chia(keepends=Sai . )bytearray.splitlines(keepends=False)

Trả về danh sách các dòng trong chuỗi nhị phân, phá vỡ ranh giới dòng ASCII. Phương pháp này sử dụng cách tiếp cận để tách dòng. Ngắt dòng không được bao gồm trong danh sách kết quả trừ khi keepends được đưa ra và đúng

For example

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
0

Unlike when a delimiter string sep is given, this method returns an empty list for the empty string, and a terminal line break does not result in an extra line

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
1

byte. swapcase()bytearray. hoán đổi()

Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ thường được chuyển đổi thành chữ hoa tương ứng của chúng và ngược lại

For example

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
2

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
53. Các ký tự ASCII chữ hoa là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
54

Không giống như , luôn luôn xảy ra trường hợp 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
71 đối với các phiên bản nhị phân. Chuyển đổi trường hợp là đối xứng trong ASCII, mặc dù điều đó thường không đúng đối với các điểm mã Unicode tùy ý

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

byte. tiêu đề()bytearray. tiêu đề()

Trả về phiên bản có tiêu đề của chuỗi nhị phân trong đó các từ bắt đầu bằng ký tự ASCII viết hoa và các ký tự còn lại là chữ thường. Uncased byte values are left unmodified

For example

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
3

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
53. Các ký tự ASCII chữ hoa là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
54. Tất cả các giá trị byte khác đều không có vỏ

The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries, which may not be the desired result

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
4

Có thể xây dựng giải pháp thay thế cho dấu nháy đơn bằng cách sử dụng biểu thức chính quy

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
5

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

byte. trên()bytearray. trên()

Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ thường được chuyển đổi thành chữ hoa tương ứng của chúng

For example

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
6

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
53. Các ký tự ASCII chữ hoa là những giá trị byte trong chuỗi 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
54

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

byte. zfill(chiều rộng)bytearray. zfill(chiều rộng)

Trả về một bản sao của chuỗi còn lại được điền bằng ASCII 

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
76 chữ số để tạo một chuỗi có chiều dài chiều rộng. Tiền tố dấu hiệu ở đầu (
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
77/ 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
78) được xử lý bằng cách chèn phần đệm sau ký tự dấu hiệu thay vì trước. Đối với các đối tượng, chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng 
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
80

For example

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
7

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

Định dạng byte kiểu 26 kiểu def to_bytes(n, length=1, byteorder='big', signed=False): if byteorder == 'little': order = range(length) elif byteorder == 'big': order = reversed(range(length)) else: raise ValueError("byteorder must be either 'little' or 'big'") return bytes((n >> i*8) & 0xff for i in order)

Ghi chú

Các hoạt động định dạng được mô tả ở đây thể hiện nhiều điểm kỳ quặc dẫn đến một số lỗi phổ biến (chẳng hạn như không hiển thị chính xác các bộ dữ liệu và từ điển). Nếu giá trị được in có thể là một bộ hoặc từ điển, hãy bọc nó trong một bộ

Các đối tượng byte (

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
23/
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
24) có một thao tác tích hợp duy nhất. toán tử 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
83 (mô-đun). Điều này còn được gọi là định dạng byte hoặc toán tử nội suy. Cho trước 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
84 (trong đó định dạng là đối tượng byte), thông số kỹ thuật chuyển đổi của 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
83 ở định dạng được thay thế bằng 0 hoặc nhiều thành phần giá trị. Hiệu quả tương tự như việc sử dụng 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
86 trong ngôn ngữ C

Nếu định dạng yêu cầu một đối số duy nhất, các giá trị có thể là một đối tượng không phải bộ dữ liệu. Mặt khác, các giá trị phải là một bộ có số mục chính xác được chỉ định bởi đối tượng byte định dạng hoặc một đối tượng ánh xạ đơn lẻ (ví dụ: từ điển)

A conversion specifier contains two or more characters and has the following components, which must occur in this order

  1. The 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    87 character, which marks the start of the specifier

  2. Mapping key (optional), consisting of a parenthesised sequence of characters (for example, 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    88)

  3. Conversion flags (optional), which affect the result of some conversion types

  4. Minimum field width (optional). If specified as an 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    89 (asterisk), the actual width is read from the next element of the tuple in values, and the object to convert comes after the minimum field width and optional precision

  5. Precision (optional), given as a 

    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    90 (dot) followed by the precision. If specified as 
    >>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
    89 (an asterisk), the actual precision is read from the next element of the tuple in values, and the value to convert comes after the precision

  6. Length modifier (optional)

  7. Conversion type

Khi đối số bên phải là một từ điển (hoặc loại ánh xạ khác), thì các định dạng trong đối tượng byte phải bao gồm khóa ánh xạ trong ngoặc đơn vào từ điển đó được chèn ngay sau ký tự 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
87. Phím ánh xạ chọn giá trị được định dạng từ ánh xạ. Ví dụ

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
8

In this case no 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
00 specifiers may occur in a format (since they require a sequential parameter list)

The conversion flag characters are

Flag

Meaning

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
94

The value conversion will use the “alternate form” (where defined below)

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
77

The conversion will be zero padded for numeric values

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
79

The converted value is left adjusted (overrides the 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
77 conversion if both are given)

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
98

(a space) A blank should be left before a positive number (or empty string) produced by a signed conversion

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
78

A sign character (

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
78 or 
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
79) will precede the conversion (overrides a “space” flag)

A length modifier (

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
02, 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
03, or 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
04) may be present, but is ignored as it is not necessary for Python – so e. g. 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
05 is identical to 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
06

The conversion types are

Conversion

Meaning

ghi chú

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
07

Signed integer decimal

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
08

Signed integer decimal

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
09

Signed octal value

(1)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
10

Loại lỗi thời – nó giống hệt với 

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
07

(8)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
12

Signed hexadecimal (lowercase)

(2)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
13

Signed hexadecimal (uppercase)

(2)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
14

Floating point exponential format (lowercase)

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
15

Floating point exponential format (uppercase)

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
16

Floating point decimal format

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
17

Floating point decimal format

(3)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
18

Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise

(4)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
19

Định dạng dấu phẩy động. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise

(4)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
20

Byte đơn (chấp nhận đối tượng số nguyên hoặc byte đơn)

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
022

Byte (bất kỳ đối tượng nào theo sau hoặc có 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
023)

(5)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
23

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
23 là bí danh của 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
022 và chỉ nên được sử dụng cho cơ sở mã Python2/3

(6)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
25

Bytes (converts any Python object using 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
028)

(5)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
21

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
21 là bí danh của 
def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
25 và chỉ nên được sử dụng cho cơ sở mã Python2/3

(7)

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
87

No argument is converted, results in a 

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
87 character in the result

ghi chú

  1. The alternate form causes a leading octal specifier (

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    29) to be inserted before the first digit

  2. The alternate form causes a leading 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    30 or 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    31 (depending on whether the 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    12 or 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    13 format was used) to be inserted before the first digit

  3. The alternate form causes the result to always contain a decimal point, even if no digits follow it

    The precision determines the number of digits after the decimal point and defaults to 6

  4. The alternate form causes the result to always contain a decimal point, and trailing zeroes are not removed as they would otherwise be

    The precision determines the number of significant digits before and after the decimal point and defaults to 6

  5. If precision is 

    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    34, the output is truncated to 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    34 characters

  6. def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    041 không được dùng nữa, nhưng sẽ không bị xóa trong 3. sê-ri x

  7. def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    042 không được dùng nữa, nhưng sẽ không bị xóa trong 3. sê-ri x

  8. See PEP 237

Ghi chú

The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made

See also

PEP 461 - Thêm % định dạng vào byte và bytearray

New in version 3. 5

Lượt xem bộ nhớ

các đối tượng cho phép mã Python truy cập dữ liệu bên trong của một đối tượng hỗ trợ mà không cần sao chép

lớp chế độ xem bộ nhớ(đối tượng)

Tạo một đối tượng tham chiếu đó. đối tượng phải hỗ trợ giao thức đệm. Các đối tượng tích hợp hỗ trợ giao thức bộ đệm bao gồm và

A có khái niệm về một phần tử, là đơn vị bộ nhớ nguyên tử được xử lý bởi đối tượng gốc. Đối với nhiều loại đơn giản như and , một phần tử là một byte đơn, nhưng các loại khác chẳng hạn như có thể có các phần tử lớn hơn

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
051 bằng chiều dài của. If 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
053, the length is 1. Nếu 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
054, độ dài bằng số phần tử trong khung nhìn. Đối với các kích thước cao hơn, độ dài bằng với độ dài của biểu diễn danh sách lồng nhau của chế độ xem. Thuộc tính sẽ cung cấp cho bạn số byte trong một phần tử

A hỗ trợ cắt và lập chỉ mục để hiển thị dữ liệu của nó. Cắt một chiều sẽ dẫn đến một chế độ xem phụ

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
9

Nếu là một trong những công cụ xác định định dạng gốc từ mô-đun, thì việc lập chỉ mục với một số nguyên hoặc một bộ số nguyên cũng được hỗ trợ và trả về một phần tử với loại chính xác. Các lần xem bộ nhớ một chiều có thể được lập chỉ mục bằng một số nguyên hoặc một bộ một số nguyên. Các lần xem bộ nhớ đa chiều có thể được lập chỉ mục với các bộ số nguyên chính xác ndim trong đó ndim là số thứ nguyên. Các lần xem bộ nhớ không chiều có thể được lập chỉ mục với bộ dữ liệu trống

Đây là một ví dụ với định dạng không phải byte

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
0

Nếu đối tượng bên dưới có thể ghi được, chế độ xem bộ nhớ hỗ trợ gán lát cắt một chiều. Thay đổi kích thước không được phép

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
1

Chế độ xem bộ nhớ một chiều của các loại có thể băm (chỉ đọc) với định dạng 'B', 'b' hoặc 'c' cũng có thể băm được. Hàm băm được định nghĩa là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
059

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
2

Đã thay đổi trong phiên bản 3. 3. Giờ đây, các lần xem bộ nhớ một chiều có thể được cắt lát. Chế độ xem bộ nhớ một chiều với các định dạng 'B', 'b' hoặc 'c' hiện có thể băm được.

Đã thay đổi trong phiên bản 3. 4. memoryview hiện được đăng ký tự động với

Đã thay đổi trong phiên bản 3. 5. lượt xem bộ nhớ hiện có thể được lập chỉ mục với bộ số nguyên.

có một số phương pháp

__eq__(nhà xuất khẩu)

Chế độ xem bộ nhớ và trình xuất PEP 3118 bằng nhau nếu hình dạng của chúng tương đương nhau và nếu tất cả các giá trị tương ứng đều bằng nhau khi mã định dạng tương ứng của toán hạng được diễn giải bằng cú pháp

Đối với tập hợp con của các chuỗi định dạng hiện được hỗ trợ bởi , 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
065 và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
066 bằng nhau nếu 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
067

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
3

Nếu một trong hai chuỗi định dạng không được mô-đun hỗ trợ, thì các đối tượng sẽ luôn so sánh là không bằng nhau (ngay cả khi các chuỗi định dạng và nội dung bộ đệm giống hệt nhau)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
4

Lưu ý rằng, như với các số dấu phẩy động, 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
069 không ngụ ý 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
070 đối với các đối tượng memoryview

Changed in version 3. 3. Các phiên bản trước so sánh bộ nhớ thô bất kể định dạng mục và cấu trúc mảng logic.

tobyte(thứ tự='C')

Trả lại dữ liệu trong bộ đệm dưới dạng chuỗi ký tự. Điều này tương đương với việc gọi hàm tạo trên memoryview

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
5

Đối với các mảng không liền kề, kết quả bằng với biểu diễn danh sách phẳng với tất cả các phần tử được chuyển đổi thành byte. hỗ trợ tất cả các chuỗi định dạng, kể cả những chuỗi không có trong cú pháp mô-đun

Mới trong phiên bản 3. 8. thứ tự có thể là {‘C’, ‘F’, ‘A’}. Khi thứ tự là 'C' hoặc 'F', dữ liệu của mảng ban đầu được chuyển thành thứ tự C hoặc Fortran. Đối với các chế độ xem liền kề, 'A' trả về một bản sao chính xác của bộ nhớ vật lý. Đặc biệt, thứ tự Fortran trong bộ nhớ được giữ nguyên. Đối với các chế độ xem không liền kề, dữ liệu được chuyển đổi thành C trước. order=None giống với order=’C’.

hex([sep[ , bytes_per_sep]])

Trả về một đối tượng chuỗi chứa hai chữ số thập lục phân cho mỗi byte trong bộ đệm

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
6

New in version 3. 5

Changed in version 3. 8. Similar to , now supports optional sep and bytes_per_sep parameters to insert separators between bytes in the hex output.

tolist()

Trả về dữ liệu trong bộ đệm dưới dạng danh sách các phần tử

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
7

Đã thay đổi trong phiên bản 3. 3. hiện hỗ trợ tất cả các định dạng gốc ký tự đơn trong cú pháp mô-đun cũng như các biểu diễn đa chiều.

chỉ đọc()

Trả về phiên bản chỉ đọc của đối tượng memoryview. Đối tượng memoryview ban đầu không thay đổi

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
8

New in version 3. 8

phát hành()

Giải phóng bộ đệm cơ bản được hiển thị bởi đối tượng memoryview. Nhiều đối tượng thực hiện các hành động đặc biệt khi một chế độ xem được giữ trên chúng (ví dụ: chế độ xem sẽ tạm thời cấm thay đổi kích thước);

Sau khi phương thức này được gọi, bất kỳ thao tác tiếp theo nào trên chế độ xem đều tăng a (ngoại trừ chính nó có thể được gọi nhiều lần)

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
9

Giao thức quản lý bối cảnh có thể được sử dụng cho hiệu ứng tương tự, sử dụng câu lệnh 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
081

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
0

New in version 3. 2

truyền(định dạng[ , shape])

Cast a memoryview to a new format or shape. hình dạng mặc định là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
082, có nghĩa là chế độ xem kết quả sẽ là một chiều. Giá trị trả về là một bộ nhớ mới, nhưng bản thân bộ đệm không được sao chép. Các phôi được hỗ trợ là 1D -> C- và C-tiếp giáp -> 1D

Định dạng đích được giới hạn ở định dạng gốc một phần tử theo cú pháp. Một trong các định dạng phải là định dạng byte ('B', 'b' hoặc 'c'). Độ dài byte của kết quả phải giống với độ dài ban đầu

Truyền 1D/dài thành 1D/byte không dấu

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
1

Truyền 1D/byte không dấu thành 1D/char

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
2

Truyền 1D/byte thành 3D/int thành 1D/char đã ký

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
3

Truyền 1D/dài không dấu thành 2D/dài không dấu

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
4

New in version 3. 3

Đã thay đổi trong phiên bản 3. 5. Định dạng nguồn không còn bị hạn chế khi truyền sang chế độ xem byte.

There are also several readonly attributes available

đối tượng

Đối tượng cơ bản của memoryview

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
5

New in version 3. 3

nbyte

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
084. Đây là lượng không gian tính bằng byte mà mảng sẽ sử dụng trong biểu diễn liền kề. Nó không nhất thiết phải bằng 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
085

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
6

mảng nhiều chiều

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
7

New in version 3. 3

chỉ đọc

Một bool cho biết bộ nhớ có ở chế độ chỉ đọc hay không

định dạng

Một chuỗi chứa định dạng (theo kiểu mô-đun) cho từng thành phần trong dạng xem. Một chế độ xem bộ nhớ có thể được tạo từ các trình xuất với các chuỗi định dạng tùy ý, nhưng một số phương thức (e. g. ) bị hạn chế đối với các định dạng phần tử đơn gốc

Đã thay đổi trong phiên bản 3. 3. format 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
088 is now handled according to the struct module syntax. This means that 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
089.

kích thước mục

Kích thước tính bằng byte của từng phần tử của memoryview

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
8

đim

Một số nguyên cho biết có bao nhiêu chiều của một mảng nhiều chiều mà bộ nhớ đại diện

hình dạng

Một bộ số nguyên có độ dài tạo ra hình dạng của bộ nhớ dưới dạng một mảng N chiều

Đã thay đổi trong phiên bản 3. 3. Một bộ trống thay vì 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31 khi ndim = 0.

sải bước

Một bộ số nguyên có độ dài đưa ra kích thước theo byte để truy cập từng phần tử cho từng chiều của mảng

Đã thay đổi trong phiên bản 3. 3. Một bộ trống thay vì 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31 khi ndim = 0.

bù trừ

Được sử dụng nội bộ cho các mảng kiểu PIL. Giá trị chỉ là thông tin

c_contiguous

Một bool cho biết liệu bộ nhớ có phải là C-

New in version 3. 3

f_tiếp giáp

Một bool cho biết bộ nhớ có phải là Fortran hay không

New in version 3. 3

tiếp giáp

Một bool cho biết liệu bộ nhớ có

New in version 3. 3

Đặt loại — ,

Một đối tượng tập hợp là một tập hợp không có thứ tự của các đối tượng riêng biệt. Các ứng dụng phổ biến bao gồm kiểm tra tư cách thành viên, loại bỏ các bản trùng lặp khỏi chuỗi và tính toán các phép toán như giao, hợp, hiệu và hiệu đối xứng. (Đối với các bộ chứa khác, hãy xem các lớp , , và tích hợp sẵn và mô-đun. )

Giống như các bộ sưu tập khác, các bộ hỗ trợ 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
100, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
101 và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
102. Là một tập hợp không có thứ tự, các tập hợp không ghi vị trí phần tử hoặc thứ tự chèn. Theo đó, các bộ không hỗ trợ lập chỉ mục, cắt hoặc hành vi giống như trình tự khác

Hiện tại có hai loại thiết lập tích hợp và. Loại có thể thay đổi — nội dung có thể được thay đổi bằng các phương thức như 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
106 và 
>>> (65).to_bytes()
b'A'
01. Vì nó có thể thay đổi nên nó không có giá trị băm và không thể được sử dụng làm khóa từ điển hoặc làm thành phần của tập hợp khác. Loại là bất biến và — không thể thay đổi nội dung của nó sau khi nó được tạo;

Ví dụ: có thể tạo các tập hợp không trống (không phải tập hợp cố định) bằng cách đặt danh sách các phần tử được phân tách bằng dấu phẩy trong dấu ngoặc nhọn. 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
109, in addition to the constructor

The constructors for both classes work the same

lớp bộ([có thể lặp lại])class frozenset([iterable])

Trả về một đối tượng set hoặc freezeset mới có các phần tử được lấy từ iterable. Các phần tử của một tập hợp phải. Để biểu diễn các tập hợp, các tập hợp bên trong phải là các đối tượng. Nếu iterable không được chỉ định, một bộ trống mới được trả về

Các bộ có thể được tạo bằng nhiều cách

  • Sử dụng danh sách các phần tử được phân tách bằng dấu phẩy trong dấu ngoặc nhọn. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    109

  • Sử dụng một bộ hiểu. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    113

  • Sử dụng hàm tạo kiểu. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    51, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    115, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    116

Các trường hợp và cung cấp các hoạt động sau

(các) ống kính

Trả về số phần tử trong tập hợp s (số lượng của s)

x in s

Kiểm tra x cho tư cách thành viên trong s

x không vào s

Kiểm tra x cho người không phải là thành viên trong s

isdisjoint(khác)

Trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu tập hợp không có phần tử nào chung với tập hợp khác. Các tập hợp là rời nhau khi và chỉ khi giao của chúng là tập hợp rỗng

issubset(other)set <= other

Kiểm tra xem mọi phần tử trong tập hợp có thuộc tập hợp khác không

đặt < khác

Kiểm tra xem tập hợp này có phải là tập con thích hợp của tập hợp khác hay không, nghĩa là, 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
120

issuperset(other)set >= other

Kiểm tra xem mọi phần tử trong tập hợp khác có nằm trong tập hợp không

đặt > khác

Kiểm tra xem tập hợp này có phải là tập hợp lớn nhất của tập hợp khác hay không, nghĩa là, 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
121

công đoàn(*những người khác)set | khác . .

Trả về một tập hợp mới với các phần tử từ tập hợp và tất cả các phần tử khác

giao lộ(*các ngã tư khác)set & other & ...

Trả về một tập hợp mới với các phần tử chung cho tập hợp và tất cả các phần tử khác

sự khác biệt(*khác)set - other - ...

Trả về một tập hợp mới với các phần tử trong tập hợp không có trong các phần tử khác

symmetric_difference(khác)đặt ^ other

Trả về một tập hợp mới có các phần tử trong tập hợp này hoặc tập hợp khác nhưng không phải cả hai

bản sao()

Trả lại một bản sao nông của tập hợp

Lưu ý, các phiên bản không phải toán tử của , , , , và các phương thức sẽ chấp nhận bất kỳ lần lặp nào làm đối số. Ngược lại, các đối tác dựa trên toán tử của chúng yêu cầu các đối số của chúng được đặt. Điều này loại bỏ các cấu trúc dễ bị lỗi như 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
128 để có thể đọc dễ dàng hơn 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
129

Cả hai và bộ hỗ trợ để đặt so sánh. Hai tập hợp bằng nhau khi và chỉ khi mọi phần tử của mỗi tập hợp đều chứa trong tập hợp kia (mỗi tập hợp này là tập con của tập hợp kia). Một tập hợp nhỏ hơn tập hợp khác khi và chỉ khi tập hợp đầu tiên là tập hợp con thực sự của tập hợp thứ hai (là tập hợp con, nhưng không bằng nhau). Một tập hợp lớn hơn tập hợp khác khi và chỉ khi tập hợp đầu tiên là tập hợp lớn nhất của tập hợp thứ hai (là tập hợp phụ, nhưng không bằng nhau)

Các trường hợp được so sánh với các trường hợp dựa trên các thành viên của chúng. Ví dụ: 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
134 trả về 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
136 cũng vậy

The subset and equality comparisons do not generalize to a total ordering function. Ví dụ: hai tập hợp khác nhau bất kỳ không rỗng thì không bằng nhau và không phải là tập con của nhau, vì vậy tất cả các giá trị sau trả về 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
138, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
139, hoặc 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
140

Vì các tập hợp chỉ xác định thứ tự một phần (mối quan hệ tập hợp con), nên đầu ra của phương thức không được xác định cho danh sách các tập hợp

Các phần tử của tập hợp, chẳng hạn như các khóa từ điển, phải là

Các hoạt động nhị phân kết hợp các trường hợp với trả về loại toán hạng đầu tiên. Ví dụ. 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
144 trả về một thể hiện của

Bảng sau đây liệt kê các hoạt động khả dụng không áp dụng cho các trường hợp bất biến của

cập nhật(*khác)set |= khác . .

Cập nhật tập hợp, thêm các phần tử từ tất cả các phần tử khác

intersection_update(*khác)set &= other & ...

Cập nhật tập hợp, chỉ giữ lại các phần tử được tìm thấy trong đó và tất cả các phần tử khác

difference_update(*khác)set -= other | .

Cập nhật tập hợp, loại bỏ các phần tử được tìm thấy trong các tập hợp khác

symmetric_difference_update(khác)đặt ^= other

Cập nhật tập hợp, chỉ giữ lại các phần tử được tìm thấy trong một trong hai tập hợp chứ không phải trong cả hai

add(elem)

Thêm phần tử elem vào tập hợp

xóa(elem)

Xóa phần tử elem khỏi tập hợp. Tăng nếu elem không được chứa trong tập hợp

loại bỏ(elem)

Xóa phần tử elem khỏi tập hợp nếu có

bốp()

Xóa và trả về một phần tử tùy ý khỏi tập hợp. Tăng nếu bộ trống

xóa()

Xóa tất cả các phần tử khỏi tập hợp

Lưu ý, các phiên bản không phải toán tử của các phương thức , , và sẽ chấp nhận bất kỳ lần lặp nào làm đối số

Note, the elem argument to the 

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
00, , and methods may be a set. Để hỗ trợ tìm kiếm một bộ đóng băng tương đương, một bộ tạm thời được tạo từ elem

Các loại ánh xạ —

Một đối tượng ánh xạ các giá trị tới các đối tượng tùy ý. Ánh xạ là các đối tượng có thể thay đổi. Hiện tại chỉ có một loại ánh xạ tiêu chuẩn, từ điển. (Đối với các bộ chứa khác, hãy xem các lớp , , và tích hợp sẵn và mô-đun. )

Các khóa của từ điển hầu như là các giá trị tùy ý. Các giá trị không phải là , nghĩa là các giá trị chứa danh sách, từ điển hoặc các loại có thể thay đổi khác (được so sánh theo giá trị thay vì theo danh tính đối tượng) có thể không được sử dụng làm khóa. Các giá trị so sánh bằng nhau (chẳng hạn như 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
55, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
163 và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56) có thể được sử dụng thay thế cho nhau để lập chỉ mục cho cùng một mục từ điển

class dict(**kwargs)class dict(mapping, **kwargs)class dict(iterable, **kwargs)

Trả về một từ điển mới được khởi tạo từ một đối số vị trí tùy chọn và một bộ đối số từ khóa có thể trống

Từ điển có thể được tạo ra bằng nhiều cách

  • Sử dụng danh sách các cặp 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    165 được phân tách bằng dấu phẩy trong dấu ngoặc nhọn. 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    166 hoặc 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    167

  • Sử dụng hiểu chính tả. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    50, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    169

  • Sử dụng hàm tạo kiểu. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    170, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    171, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    172

Nếu không có đối số vị trí nào được đưa ra, một từ điển trống sẽ được tạo. Nếu một đối số vị trí được đưa ra và nó là một đối tượng ánh xạ, thì một từ điển sẽ được tạo với các cặp khóa-giá trị giống như đối tượng ánh xạ. Mặt khác, đối số vị trí phải là một đối tượng. Bản thân mỗi mục trong iterable phải là iterable với chính xác hai đối tượng. Đối tượng đầu tiên của mỗi mục trở thành một khóa trong từ điển mới và đối tượng thứ hai là giá trị tương ứng. Nếu một khóa xuất hiện nhiều lần, giá trị cuối cùng của khóa đó sẽ trở thành giá trị tương ứng trong từ điển mới

Nếu các đối số từ khóa được đưa ra, thì các đối số từ khóa và giá trị của chúng sẽ được thêm vào từ điển được tạo từ đối số vị trí. Nếu một khóa đang được thêm đã xuất hiện, thì giá trị từ đối số từ khóa sẽ thay thế giá trị từ đối số vị trí

Để minh họa, tất cả các ví dụ sau đều trả về một từ điển bằng 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
173

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
9

Việc cung cấp các đối số từ khóa như trong ví dụ đầu tiên chỉ hoạt động đối với các khóa là mã định danh Python hợp lệ. Mặt khác, bất kỳ khóa hợp lệ nào cũng có thể được sử dụng

Đây là những hoạt động mà từ điển hỗ trợ (và do đó, các loại ánh xạ tùy chỉnh cũng sẽ hỗ trợ)

danh sách(d)

Trả về danh sách tất cả các khóa được sử dụng trong từ điển d

cho vay)

Trả về số mục trong từ điển d

đ[phím]

Return the item of d with key key. Raises a if key is not in the map

Nếu một lớp con của dict định nghĩa một phương thức 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
175 và không có khóa, thì thao tác 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
176 gọi phương thức đó với đối số là key key. Hoạt động 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
176 sau đó trả lại hoặc tăng bất cứ thứ gì được trả lại hoặc tăng bởi lệnh gọi 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
178. Không có hoạt động hoặc phương pháp nào khác gọi 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
175. Nếu 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
175 không được xác định, được nâng lên. 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
175 phải là một phương thức; 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
00

Ví dụ trên cho thấy một phần của việc thực hiện. Một phương pháp 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
184 khác được sử dụng bởi

d[key] = giá trị

Đặt 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
176 thành giá trị

del d[key]

Xóa 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
176 khỏi d. Tăng phím if không có trong bản đồ

phím vào d

Trả lại 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 nếu d có khóa chính, ngược lại 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38

phím không vào d

Tương đương với 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
191

lặp đi lặp lại (d)

Return an iterator over the keys of the dictionary. Đây là lối tắt cho 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
192

xóa()

Xóa tất cả các mục khỏi từ điển

bản sao()

Trả lại một bản sao nông của từ điển

phương thức lớp từ khóa(có thể lặp lại[, value])

Tạo một từ điển mới với các khóa từ iterable và các giá trị được đặt thành giá trị

là một phương thức lớp trả về một từ điển mới. giá trị mặc định là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31. Tất cả các giá trị chỉ tham chiếu đến một thể hiện duy nhất, do đó, thông thường giá trị là một đối tượng có thể thay đổi chẳng hạn như một danh sách trống không có ý nghĩa gì. Để có được các giá trị riêng biệt, hãy sử dụng thay thế

lấy(khóa[ , default])

Trả về giá trị cho khóa nếu khóa có trong từ điển, nếu không thì mặc định. Nếu giá trị mặc định không được đưa ra, nó sẽ mặc định là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31, do đó phương thức này không bao giờ tăng

item()

Trả về chế độ xem mới cho các mục của từ điển (

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
197 cặp). xem

phím()

Trả lại chế độ xem mới cho các khóa của từ điển. See the

bật(phím[ , default])

Nếu khóa nằm trong từ điển, hãy xóa nó và trả về giá trị của nó, nếu không thì trả về giá trị mặc định. Nếu giá trị mặc định không được cung cấp và khóa không có trong từ điển, a sẽ tăng

popitem()

Xóa và trả về cặp 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
197 từ từ điển. Các cặp được trả lại theo thứ tự LIFO

rất hữu ích để lặp lại triệt để một từ điển, như thường được sử dụng trong các thuật toán tập hợp. Nếu từ điển trống, việc gọi sẽ tăng

Đã thay đổi trong phiên bản 3. 7. Đơn hàng LIFO hiện đã được đảm bảo. Trong các phiên bản trước, sẽ trả về một cặp khóa/giá trị tùy ý.

đảo ngược(d)

Trả về một trình vòng lặp đảo ngược trên các khóa của từ điển. Đây là lối tắt cho 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
204

New in version 3. 8

setdefault(key[ , default])

Nếu khóa nằm trong từ điển, hãy trả về giá trị của nó. Nếu không, hãy chèn khóa có giá trị mặc định và trả về giá trị mặc định. default defaults to 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31

cập nhật([khác])

Cập nhật từ điển với các cặp khóa/giá trị từ khác, ghi đè lên các khóa hiện có. Trả lại 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31

chấp nhận một đối tượng từ điển khác hoặc một cặp khóa/giá trị có thể lặp lại (dưới dạng bộ dữ liệu hoặc các lần lặp khác có độ dài hai). Nếu các đối số từ khóa được chỉ định, thì từ điển sẽ được cập nhật với các cặp khóa/giá trị đó. 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
208

giá trị()

Trả lại chế độ xem mới về các giá trị của từ điển. xem

So sánh bình đẳng giữa một chế độ xem 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
209 và chế độ xem khác sẽ luôn trả về 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38. Điều này cũng áp dụng khi so sánh 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
209 với chính nó

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
01

d . khác

Tạo một từ điển mới với các khóa và giá trị được hợp nhất của d và khác, cả hai phải là từ điển. Các giá trị của other được ưu tiên khi d và các khóa chia sẻ khác

New in version 3. 9

d . = other

Cập nhật từ điển d với các khóa và giá trị từ từ khác, có thể là a hoặc một trong các cặp khóa/giá trị. Các giá trị của other được ưu tiên khi d và các khóa chia sẻ khác

New in version 3. 9

Dictionaries compare equal if and only if they have the same 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
197 pairs (regardless of ordering). Order comparisons (‘<’, ‘<=’, ‘>=’, ‘>’) raise .

Từ điển bảo toàn thứ tự chèn. Lưu ý rằng việc cập nhật khóa không ảnh hưởng đến thứ tự. Các phím được thêm sau khi xóa được chèn vào cuối

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
02

Đã thay đổi trong phiên bản 3. 7. Thứ tự từ điển được đảm bảo là thứ tự chèn. Hành vi này là một chi tiết triển khai của CPython từ 3. 6.

Từ điển và chế độ xem từ điển có thể đảo ngược

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
03

Đã thay đổi trong phiên bản 3. 8. Từ điển hiện có thể đảo ngược.

See also

can be used to create a read-only view of a

Các đối tượng xem từ điển

Các đối tượng được trả về và là các đối tượng xem. Chúng cung cấp chế độ xem động cho các mục nhập của từ điển, có nghĩa là khi từ điển thay đổi, chế độ xem sẽ phản ánh những thay đổi này

Chế độ xem từ điển có thể được lặp đi lặp lại để mang lại dữ liệu tương ứng và hỗ trợ kiểm tra tư cách thành viên

len(dictview)

Trả về số mục trong từ điển

lặp đi lặp lại (dictview)

Trả về một trình vòng lặp trên các khóa, giá trị hoặc mục (được biểu thị dưới dạng bộ dữ liệu của 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
197) trong từ điển

Các khóa và giá trị được lặp lại theo thứ tự chèn. Điều này cho phép tạo ra các cặp 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
220 bằng cách sử dụng. ______________222. Một cách khác để tạo danh sách tương tự là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
223

Lặp lại các dạng xem trong khi thêm hoặc xóa các mục trong từ điển có thể gây ra hoặc không thể lặp lại trên tất cả các mục

Đã thay đổi trong phiên bản 3. 7. Thứ tự từ điển được đảm bảo là thứ tự chèn.

x trong dictview

Return 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56 if x is in the underlying dictionary’s keys, values or items (in the latter case, x should be a 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
197 tuple)

đảo ngược (dictview)

Trả về một trình lặp đảo ngược trên các khóa, giá trị hoặc mục của từ điển. Chế độ xem sẽ được lặp lại theo thứ tự ngược lại của phần chèn

Đã thay đổi trong phiên bản 3. 8. Chế độ xem từ điển hiện có thể đảo ngược.

chế độ xem chính tả. lập bản đồ

Trả lại a bao bọc từ điển gốc mà chế độ xem đề cập đến

New in version 3. 10

Chế độ xem khóa giống như được đặt vì các mục nhập của chúng là duy nhất và có thể băm. Nếu tất cả các giá trị đều có thể băm, để các cặp 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
197 là duy nhất và có thể băm, thì chế độ xem các mục cũng giống như được đặt. (Chế độ xem giá trị không được coi là giống như tập hợp vì các mục thường không phải là duy nhất. ) Đối với các khung nhìn dạng tập hợp, tất cả các thao tác được định nghĩa cho lớp cơ sở trừu tượng đều khả dụng (ví dụ: 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
78, 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
74 hoặc 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
232)

Một ví dụ về việc sử dụng chế độ xem từ điển

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
04

Các loại trình quản lý bối cảnh

Câu lệnh của Python hỗ trợ khái niệm bối cảnh thời gian chạy được xác định bởi trình quản lý bối cảnh. Điều này được thực hiện bằng cách sử dụng một cặp phương thức cho phép các lớp do người dùng định nghĩa xác định bối cảnh thời gian chạy được nhập vào trước khi phần thân câu lệnh được thực thi và thoát khi câu lệnh kết thúc

contextmanager. __enter__()

Nhập bối cảnh thời gian chạy và trả về đối tượng này hoặc đối tượng khác liên quan đến bối cảnh thời gian chạy. Giá trị được phương thức này trả về được liên kết với mã định danh trong mệnh đề 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
234 của các câu lệnh sử dụng trình quản lý bối cảnh này

Một ví dụ về trình quản lý bối cảnh tự trả về là một. Các đối tượng tệp tự trả về từ __enter__() để cho phép được sử dụng làm biểu thức ngữ cảnh trong câu lệnh

Một ví dụ về trình quản lý bối cảnh trả về một đối tượng liên quan là đối tượng được trả về bởi. Các trình quản lý này đặt ngữ cảnh thập phân đang hoạt động thành một bản sao của ngữ cảnh thập phân ban đầu rồi trả lại bản sao. Điều này cho phép thực hiện các thay đổi đối với ngữ cảnh thập phân hiện tại trong phần thân của câu lệnh mà không ảnh hưởng đến mã bên ngoài câu lệnh 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
081

trình quản lý ngữ cảnh. __exit__(exc_type , exc_val, exc_tb)

Thoát khỏi bối cảnh thời gian chạy và trả về một cờ Boolean cho biết liệu có nên loại bỏ bất kỳ ngoại lệ nào xảy ra hay không. Nếu một ngoại lệ xảy ra trong khi thực thi phần thân của câu lệnh, thì các đối số chứa loại ngoại lệ, giá trị và thông tin truy nguyên. Mặt khác, cả ba đối số đều là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31

Trả về giá trị thực từ phương thức này sẽ khiến câu lệnh chặn ngoại lệ và tiếp tục thực hiện với câu lệnh ngay sau câu lệnh 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
081. Mặt khác, ngoại lệ tiếp tục lan truyền sau khi phương thức này thực hiện xong. Các ngoại lệ xảy ra trong quá trình thực thi phương thức này sẽ thay thế bất kỳ ngoại lệ nào xảy ra trong phần thân của câu lệnh 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
081

Ngoại lệ được truyền vào không bao giờ được gọi lại một cách rõ ràng - thay vào đó, phương thức này sẽ trả về một giá trị sai để cho biết rằng phương thức đã hoàn tất thành công và không muốn chặn ngoại lệ đã nêu. Điều này cho phép mã quản lý bối cảnh dễ dàng phát hiện xem một phương thức có thực sự bị lỗi hay không

Python defines several context managers to support easy thread synchronisation, prompt closure of files or other objects, and simpler manipulation of the active decimal arithmetic context. Các loại cụ thể không được xử lý đặc biệt ngoài việc thực hiện giao thức quản lý ngữ cảnh. Xem mô-đun để biết một số ví dụ

Python's và trình trang trí cung cấp một cách thuận tiện để triển khai các giao thức này. Nếu một hàm tạo được trang trí bằng trình tạo trang trí, thì nó sẽ trả về trình quản lý ngữ cảnh thực hiện các phương thức và cần thiết, thay vì trình vòng lặp được tạo bởi hàm tạo không được trang trí

Lưu ý rằng không có vị trí cụ thể nào cho bất kỳ phương thức nào trong số này trong cấu trúc kiểu cho các đối tượng Python trong API Python/C. Các loại tiện ích mở rộng muốn xác định các phương thức này phải cung cấp chúng như một phương thức truy cập Python thông thường. So với chi phí thiết lập bối cảnh thời gian chạy, chi phí hoạt động của một tra cứu từ điển một lớp là không đáng kể

Nhập các loại chú thích — ,

Các loại tích hợp sẵn cốt lõi cho are và

Loại bí danh chung

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 đối tượng thường được tạo bởi một lớp. Chúng thường được sử dụng với , chẳng hạn như hoặc. Ví dụ: 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
255 là một đối tượng 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 được tạo bằng cách đăng ký lớp 
def bit_count(self):
    return bin(self).count("1")
93 với đối số. 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 đối tượng được dự định chủ yếu để sử dụng với

Ghi chú

Nói chung, chỉ có thể đăng ký một lớp nếu lớp đó thực hiện phương thức đặc biệt

Một đối tượng 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 hoạt động như một proxy cho một , triển khai các generic được tham số hóa

Đối với một lớp chứa, (các) đối số được cung cấp cho một lớp có thể chỉ ra (các) loại phần tử mà một đối tượng chứa. Ví dụ: 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
262 có thể được sử dụng trong chú thích loại để biểu thị một trong đó tất cả các phần tử đều thuộc loại

For a class which defines but is not a container, the argument(s) supplied to a subscription of the class will often indicate the return type(s) of one or more methods defined on an object. Ví dụ, có thể được sử dụng trên cả kiểu dữ liệu và kiểu dữ liệu

  • Nếu 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    269, thì 
    >>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3
    82 sẽ là một đối tượng mà các giá trị trả về của 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    271 và 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    272 đều thuộc loại. Chúng ta có thể biểu diễn loại đối tượng này trong các chú thích kiểu với 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    252 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    275

  • Nếu 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    276, (lưu ý 
    def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n
    47 cho ), thì 
    def bit_count(self):
    return bin(self).count("1")
    31 cũng sẽ là một thể hiện của 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    280, nhưng các giá trị trả về của 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    281 và 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    282 đều thuộc loại. Trong chú thích loại, chúng tôi sẽ đại diện cho nhiều đối tượng này bằng 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    284

Các đối tượng 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 là các thể hiện của lớp, cũng có thể được sử dụng để tạo trực tiếp các đối tượng 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252

T[X, Y, . ]

Tạo một 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 đại diện cho một loại 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
289 được tham số hóa bởi các loại X, Y, v.v. tùy thuộc vào 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
289 được sử dụng. Ví dụ: một hàm mong đợi một phần tử chứa

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
05

Một ví dụ khác cho các đối tượng, sử dụng a , là loại chung mong đợi hai tham số loại đại diện cho loại khóa và loại giá trị. Trong ví dụ này, hàm mong đợi một 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
68 với các khóa thuộc loại và các giá trị thuộc loại

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
06

Các hàm dựng sẵn và không chấp nhận các loại 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 cho đối số thứ hai của chúng

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
07

Thời gian chạy Python không thực thi. Điều này mở rộng đến các loại chung và các tham số loại của chúng. When creating a container object from a 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252, the elements in the container are not checked against their type. Ví dụ: đoạn mã sau không được khuyến khích nhưng sẽ chạy không có lỗi

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
08

Hơn nữa, các tham số loại được tham số hóa xóa các tham số loại trong quá trình tạo đối tượng

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
09

Gọi hoặc trên chung hiển thị loại được tham số hóa

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
10

Phương thức của các thùng chứa chung sẽ đưa ra một ngoại lệ để không cho phép các lỗi như 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
304

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
11

Tuy nhiên, các biểu thức như vậy có giá trị khi được sử dụng. Chỉ mục phải có nhiều phần tử bằng với số mục biến loại trong đối tượng 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
12

Các lớp chung tiêu chuẩn

Các lớp thư viện tiêu chuẩn sau đây hỗ trợ các generic được tham số hóa. danh sách này là không đầy đủ

Thuộc tính đặc biệt của 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 đối tượng

Tất cả các generic được tham số hóa đều triển khai các thuộc tính chỉ đọc đặc biệt

tên chung. __origin__

Thuộc tính này chỉ vào lớp chung không tham số hóa

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
13

genericalias. __args__

Thuộc tính này là (có thể có độ dài 1) của các loại chung được truyền cho bản gốc của lớp chung

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
14

tên chung. __tham số__

Thuộc tính này là một bộ được tính toán chậm (có thể trống) gồm các biến loại duy nhất được tìm thấy trong 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
306

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
15

Ghi chú

Một đối tượng 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
252 với các tham số có thể không đúng với 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
365 sau khi thay thế vì mục đích chủ yếu là để kiểm tra kiểu tĩnh

tên chung. __unpacked__

Một giá trị boolean đúng nếu bí danh đã được giải nén bằng cách sử dụng toán tử 

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
00 (xem phần )

Mới trong phiên bản 3. 11

See also

PEP 484 - Gợi ý loại

Giới thiệu khung của Python cho các chú thích loại

PEP 585 - Nhập gợi ý Generics trong bộ sưu tập tiêu chuẩn

Giới thiệu khả năng tham số hóa các lớp thư viện tiêu chuẩn, miễn là chúng triển khai phương thức lớp đặc biệt

, và

Documentation on how to implement generic classes that can be parameterized at runtime and understood by static type-checkers

New in version 3. 9

Loại liên minh

Một đối tượng hợp giữ giá trị của phép toán 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
371 (theo bit hoặc) trên nhiều. Các loại này chủ yếu dành cho. Biểu thức kiểu kết hợp cho phép cú pháp gợi ý kiểu sạch hơn so với

X . Y . .

Xác định một đối tượng kết hợp chứa các loại X, Y, v.v. 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
373 có nghĩa là X hoặc Y. Nó tương đương với 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
374. Ví dụ: hàm sau mong đợi một đối số kiểu hoặc

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
16

union_object == khác

Các đối tượng kết hợp có thể được kiểm tra sự bình đẳng với các đối tượng kết hợp khác. Thông tin chi tiết

  • Unions of unions are flattened

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    17

  • Các loại dư thừa được loại bỏ

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    18

  • Khi so sánh các công đoàn, thứ tự bị bỏ qua

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    19

  • Nó tương thích với

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    20

  • Các loại tùy chọn có thể được viết dưới dạng hợp nhất với 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    31

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    21

isinstance(obj, union_object)issubclass(obj, union_object)

Các cuộc gọi đến và cũng được hỗ trợ với một đối tượng hợp nhất

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
22

Tuy nhiên, không thể sử dụng các đối tượng hợp có chứa

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
23

Loại tiếp xúc với người dùng cho đối tượng hợp nhất có thể được truy cập và sử dụng để kiểm tra. Một đối tượng không thể được khởi tạo từ loại

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
24

Ghi chú

Phương thức 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
383 cho các đối tượng kiểu đã được thêm vào để hỗ trợ cú pháp 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
373. If a metaclass implements 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
383, the Union may override it

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
25

See also

PEP 604 – PEP đề xuất cú pháp 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
373 và kiểu Union

New in version 3. 10

Các loại tích hợp khác

Trình thông dịch hỗ trợ một số loại đối tượng khác. Hầu hết trong số này chỉ hỗ trợ một hoặc hai thao tác

mô-đun

Hoạt động đặc biệt duy nhất trên một mô-đun là truy cập thuộc tính. 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
387, trong đó m là một mô-đun và tên truy cập vào tên được xác định trong bảng ký hiệu của m. Thuộc tính mô-đun có thể được gán cho. (Lưu ý rằng, nói một cách chính xác, câu lệnh không phải là một thao tác trên đối tượng mô-đun; 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
389 không yêu cầu đối tượng mô-đun có tên foo tồn tại, thay vào đó, nó yêu cầu một định nghĩa (bên ngoài) cho một mô-đun có tên foo ở đâu đó. )

Một thuộc tính đặc biệt của mỗi mô-đun là. Đây là từ điển chứa bảng ký hiệu của module. Sửa đổi từ điển này sẽ thực sự thay đổi bảng ký hiệu của mô-đun, nhưng không thể gán trực tiếp cho thuộc tính (bạn có thể viết 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
392, định nghĩa 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
393 là ________0____55, nhưng bạn không thể viết 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
395). Sửa đổi trực tiếp không được khuyến khích

Các mô-đun được tích hợp trong trình thông dịch được viết như thế này. 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
397. Nếu được tải từ một tệp, chúng được viết là 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
398

Các lớp và trường hợp lớp

See and for these

Chức năng

Các đối tượng hàm được tạo bởi các định nghĩa hàm. Thao tác duy nhất trên một đối tượng hàm là gọi nó. 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
399

Thực sự có hai hương vị của các đối tượng chức năng. chức năng tích hợp và chức năng do người dùng định nghĩa. Cả hai đều hỗ trợ cùng một thao tác (để gọi hàm), nhưng cách triển khai thì khác nhau, do đó các loại đối tượng khác nhau

Xem để biết thêm thông tin

phương pháp

Phương thức là các hàm được gọi bằng cách sử dụng ký hiệu thuộc tính. Có hai hương vị. các phương thức tích hợp sẵn (chẳng hạn như 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
400 trong danh sách) và các phương thức thể hiện của lớp. Các phương thức tích hợp được mô tả với các loại hỗ trợ chúng

Nếu bạn truy cập một phương thức (một hàm được định nghĩa trong một không gian tên lớp) thông qua một thể hiện, bạn sẽ nhận được một đối tượng đặc biệt. một đối tượng phương thức ràng buộc (còn gọi là phương thức thể hiện). Khi được gọi, nó sẽ thêm đối số 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
401 vào danh sách đối số. Các phương thức ràng buộc có hai thuộc tính chỉ đọc đặc biệt. 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
402 is the object on which the method operates, and 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
403 is the function implementing the method. Gọi 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
404 hoàn toàn tương đương với gọi 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
405

Giống như các đối tượng hàm, các đối tượng phương thức ràng buộc hỗ trợ nhận các thuộc tính tùy ý. Tuy nhiên, vì các thuộc tính của phương thức thực sự được lưu trữ trên đối tượng chức năng bên dưới (

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
406), nên việc đặt các thuộc tính của phương thức trên các phương thức bị ràng buộc là không được phép. Cố gắng đặt một thuộc tính trên một phương thức dẫn đến việc tăng. In order to set a method attribute, you need to explicitly set it on the underlying function object

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
26

Xem để biết thêm thông tin

Code Objects

Code objects are used by the implementation to represent “pseudo-compiled” executable Python code such as a function body. They differ from function objects because they don’t contain a reference to their global execution environment. Code objects are returned by the built-in function and can be extracted from function objects through their 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
409 attribute. See also the module

Accessing 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
409 raises an 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
412 with arguments 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
413 and 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
414

A code object can be executed or evaluated by passing it (instead of a source string) to the or built-in functions

Xem để biết thêm thông tin

Type Objects

Loại đối tượng đại diện cho các loại đối tượng khác nhau. Loại đối tượng được truy cập bởi chức năng tích hợp. Không có thao tác đặc biệt nào trên các loại. Mô-đun tiêu chuẩn xác định tên cho tất cả các loại tích hợp tiêu chuẩn

Các loại được viết như thế này. ______________419

Đối tượng Null

Đối tượng này được trả về bởi các hàm không trả về giá trị một cách rõ ràng. Nó không hỗ trợ các hoạt động đặc biệt. There is exactly one null object, named 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31 (a built-in name). 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
421 tạo ra cùng một singleton

Nó được viết là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
31

Đối tượng Dấu chấm lửng

Đối tượng này thường được sử dụng bằng cách cắt (xem ). Nó không hỗ trợ các hoạt động đặc biệt. Có chính xác một đối tượng dấu chấm lửng, được đặt tên (tên tích hợp). 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
424 sản xuất singleton

Nó được viết là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
423 hoặc 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
427

Đối tượng không được triển khai

Đối tượng này được trả về từ phép so sánh và phép toán nhị phân khi chúng được yêu cầu thao tác trên các loại mà chúng không hỗ trợ. Xem để biết thêm thông tin. Có chính xác một đối tượng 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
428. 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
429 tạo ra cá thể đơn lẻ

Nó được viết là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
428

Giá trị Boolean

Giá trị Boolean là hai đối tượng hằng số 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56. Chúng được sử dụng để biểu thị giá trị thật (mặc dù các giá trị khác cũng có thể được coi là sai hoặc đúng). Trong ngữ cảnh số (ví dụ: khi được sử dụng làm đối số cho toán tử số học), chúng hoạt động giống như các số nguyên 0 và 1 tương ứng. The built-in function can be used to convert any value to a Boolean, if the value can be interpreted as a truth value (see section above)

Chúng được viết lần lượt là 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
38 và 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
56

Đối tượng bên trong

Xem thông tin này. Nó mô tả các đối tượng khung ngăn xếp, đối tượng truy nguyên và đối tượng lát

Thuộc tính đặc biệt

Việc triển khai thêm một vài thuộc tính chỉ đọc đặc biệt cho một số loại đối tượng, nơi chúng có liên quan. Một số trong số này không được báo cáo bởi chức năng tích hợp

đối tượng. __dict__

Từ điển hoặc đối tượng ánh xạ khác được sử dụng để lưu trữ các thuộc tính (có thể ghi) của đối tượng

ví dụ. __class__

Lớp mà một thể hiện của lớp thuộc về

lớp. __base__

Bộ các lớp cơ sở của một đối tượng lớp

định nghĩa. __name__

The name of the class, function, method, descriptor, or generator instance

definition. __qualname__

Thể hiện của lớp, hàm, phương thức, bộ mô tả hoặc trình tạo

New in version 3. 3

lớp. __mro__

Thuộc tính này là một bộ các lớp được xem xét khi tìm kiếm các lớp cơ sở trong quá trình phân giải phương thức

lớp. mro()

Phương thức này có thể được ghi đè bởi một siêu dữ liệu để tùy chỉnh thứ tự phân giải phương thức cho các phiên bản của nó. Nó được gọi khi khởi tạo lớp và kết quả của nó được lưu trữ trong

lớp. __phân lớp__()

Mỗi lớp giữ một danh sách các tham chiếu yếu đến các lớp con trực tiếp của nó. Phương thức này trả về một danh sách tất cả những tham chiếu vẫn còn tồn tại. Danh sách theo thứ tự định nghĩa. Thí dụ

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
27

Giới hạn độ dài chuyển đổi chuỗi số nguyên

CPython có giới hạn toàn cầu để chuyển đổi giữa và để giảm thiểu các cuộc tấn công từ chối dịch vụ. This limit only applies to decimal or other non-power-of-two number bases. Chuyển đổi thập lục phân, bát phân và nhị phân là không giới hạn. Giới hạn có thể được cấu hình

Loại trong Python là một số có độ dài tùy ý được lưu trữ ở dạng nhị phân (thường được gọi là “bignum”). Không tồn tại thuật toán nào có thể chuyển đổi một chuỗi thành một số nguyên nhị phân hoặc một số nguyên nhị phân thành một chuỗi trong thời gian tuyến tính, trừ khi cơ số là lũy thừa của 2. Ngay cả các thuật toán được biết đến nhiều nhất cho cơ số 10 cũng có độ phức tạp bậc hai. Chuyển đổi một giá trị lớn chẳng hạn như 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
441 có thể mất hơn một giây trên CPU nhanh

Giới hạn kích thước chuyển đổi cung cấp một cách thiết thực để tránh CVE-2020-10735

Giới hạn được áp dụng cho số ký tự chữ số trong chuỗi đầu vào hoặc đầu ra khi sử dụng thuật toán chuyển đổi phi tuyến tính. Dấu gạch dưới và dấu không được tính vào giới hạn

Khi một hoạt động sẽ vượt quá giới hạn, a được nâng lên

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
28

Giới hạn mặc định là 4300 chữ số như được cung cấp trong. Giới hạn thấp nhất có thể được cấu hình là 640 chữ số như được cung cấp trong

xác minh

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
29

Mới trong phiên bản 3. 11

API bị ảnh hưởng

Giới hạn chỉ áp dụng cho các chuyển đổi có khả năng chậm giữa và hoặc

  • def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    448 với cơ số mặc định là 10

  • def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    449 for all bases that are not a power of 2

  • def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    450

  • ______________451

  • bất kỳ chuyển đổi chuỗi nào khác sang cơ số 10, ví dụ: 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    452, 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    453 hoặc 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    454

Các giới hạn không áp dụng cho các hàm có thuật toán tuyến tính

  • def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    449 với cơ số 2, 4, 8, 16 hoặc 32

  • và

  • , ,

  • cho các số hex, bát phân và nhị phân

  • đến

  • đến

Định cấu hình giới hạn

Trước khi Python khởi động, bạn có thể sử dụng biến môi trường hoặc cờ dòng lệnh của trình thông dịch để định cấu hình giới hạn

  • , e. g. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    466 để đặt giới hạn thành 640 hoặc 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    467 để tắt giới hạn

  • , e. g. 

    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    469

  • def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    470 chứa giá trị của hoặc. Nếu cả tùy chọn env var và tùy chọn 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    473 được đặt, thì tùy chọn 
    def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
    473 sẽ được ưu tiên. Giá trị -1 cho biết rằng cả hai đều không được đặt, do đó, giá trị ____0_______443 đã được sử dụng trong quá trình khởi tạo

Từ mã, bạn có thể kiểm tra giới hạn hiện tại và đặt giới hạn mới bằng các API này

  • và là một getter và setter cho giới hạn trên toàn trình thông dịch. Phiên dịch viên phụ có giới hạn riêng của họ

Thông tin về mặc định và tối thiểu có thể được tìm thấy trong

  • là giới hạn mặc định được biên dịch

  • là giá trị thấp nhất được chấp nhận cho giới hạn (khác 0 sẽ vô hiệu hóa giới hạn đó)

Mới trong phiên bản 3. 11

thận trọng

Đặt giới hạn thấp có thể dẫn đến sự cố. Mặc dù hiếm gặp, mã tồn tại chứa các hằng số nguyên ở dạng thập phân trong nguồn của chúng vượt quá ngưỡng tối thiểu. Hệ quả của việc đặt giới hạn là mã nguồn Python chứa các số nguyên thập phân dài hơn giới hạn sẽ gặp lỗi trong quá trình phân tích cú pháp, thường là tại thời điểm khởi động hoặc thời điểm nhập hoặc thậm chí tại thời điểm cài đặt - bất kỳ lúc nào bản cập nhật _______ 482 chưa tồn tại cho . Một giải pháp thay thế cho nguồn chứa các hằng số lớn như vậy là chuyển đổi chúng sang dạng thập lục phân 

def bit_count(self):
    return bin(self).count("1")
12 vì nó không có giới hạn

Kiểm tra ứng dụng của bạn kỹ lưỡng nếu bạn sử dụng giới hạn thấp. Đảm bảo các thử nghiệm của bạn chạy với giới hạn được đặt sớm thông qua môi trường hoặc cờ để nó áp dụng trong quá trình khởi động và thậm chí trong bất kỳ bước cài đặt nào có thể gọi Python để biên dịch trước các nguồn 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
484 thành tệp 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
482

Cấu hình đề xuất

Giá trị mặc định 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
443 dự kiến ​​sẽ hợp lý cho hầu hết các ứng dụng. Nếu ứng dụng của bạn yêu cầu một giới hạn khác, hãy đặt giới hạn đó từ điểm vào chính của bạn bằng cách sử dụng mã bất khả tri của phiên bản Python vì các API này đã được thêm vào trong các bản phát hành bản vá bảo mật ở các phiên bản trước 3. 11

Example

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
30

Nếu bạn cần tắt hoàn toàn, hãy đặt thành 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
42

chú thích

Thông tin bổ sung về các phương pháp đặc biệt này có thể được tìm thấy trong Python Reference Manual ()

Kết quả là, danh sách 

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
488 được coi là bằng với 
def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6
489, và tương tự đối với các bộ dữ liệu

Chúng phải có vì trình phân tích cú pháp không thể cho biết loại toán hạng

4(,,,)

Các ký tự viết hoa là những ký tự có thuộc tính danh mục chung là một trong số “Lu” (Chữ cái, chữ hoa), “Ll” (Chữ cái, chữ thường) hoặc “Lt” (Chữ cái, chữ hoa tiêu đề)

5(,)

Do đó, để chỉ định dạng một bộ dữ liệu, bạn nên cung cấp một bộ dữ liệu đơn có phần tử duy nhất là bộ dữ liệu được định dạng

cái gì là. trong Python?

Python sử dụng. để phân tách giá trị Kết thúc, Bắt đầu và Bước .

có nghĩa là gì [. 4 có nghĩa là gì trong Python?

Đối với bất kỳ lần lặp nào trong python [-4. ] biểu thị việc lập chỉ mục cho bốn mục cuối cùng của lần lặp đó .

programming python

Bài Viết Liên Quan

Đối tượng trả về php thay vì mảng
Đối tượng trả về php thay vì mảng

Laravel không IN truy vấn phụ
Laravel không IN truy vấn phụ

Cách gán số cho một từ trong Excel
Cách gán số cho một từ trong Excel

Cách gọi một hàm bên trong một lớp python
Cách gọi một hàm bên trong một lớp python

Rượu Vodka Việt Nam bao nhiêu độ?
Rượu Vodka Việt Nam bao nhiêu độ?

Plugin nhiều chủ đề WordPress
Plugin nhiều chủ đề WordPress

Câu hỏi phỏng vấn javascript coderpad
Câu hỏi phỏng vấn javascript coderpad

Làm cách nào để in chuỗi Unicode trong Python3?
Làm cách nào để in chuỗi Unicode trong Python3?

Số nửa kim tự tháp trong Python
Số nửa kim tự tháp trong Python

Làm cách nào để tìm một biến trong python?
Làm cách nào để tìm một biến trong python?

MỚI CẬP NHẬP

Code matlab lọc trung bình có trọng số năm 2024
5 phúts trước . bởi AccurateSweepstakes
Cái đáng quý của hạnh phúc gia đình là gì năm 2024
20 phúts trước . bởi PhilosophicSaturday
Bài tập bảng băm phương pháp nối kết trực tiếp năm 2024
41 phúts trước . bởi DeceptiveElements
Top plus uniform đồng phục lớp đẹp & chất năm 2024
1 giờs trước . bởi CrampedApplause
Giải sách giáo khoa toán lớp 4 trang 48 năm 2024
1 giờs trước . bởi CrampedSperm
Tính toán thiết kế đường ống khí nén năm 2024
1 giờs trước . bởi Post-warNuisance
Giải tỏa căng thẳng trong tiếng anh là gì năm 2024
1 giờs trước . bởi IcyBattling
Khám nội tiết nữ là khám những gì năm 2024
1 giờs trước . bởi HalfwayBrunt
Bản tường trình bài thực hành 1 hóa học 9 năm 2024
2 giờs trước . bởi PunyLicence
Vũ trụ và ứng dụng là học về cái gì năm 2024
2 giờs trước . bởi SpatialAltercation

Xem Nhiều

On the weekend là thì gì năm 2024
6 ngàys trước . bởi FierceCovering
Co số điện thoại di động nào 9 đó năm 2024
4 ngàys trước . bởi SilverTo-day
Himax premium lub ts40 là gì năm 2024
4 ngàys trước . bởi DeepeningMirth
81 2 nguyễn văn giai quận 1 f dakao năm 2024
4 ngàys trước . bởi First-rateMedics
Cách mạng công nghiệp 4.0 cơ hội nào cho startup năm 2024
2 ngàys trước . bởi SinfulBoldness
Các dạng toán chương 1 kinh tế vĩ mô năm 2024
23 giờs trước . bởi HeathenPolling
Cấu trúc tiếng anh là con nghiện của cái gì năm 2024
6 ngàys trước . bởi AspiringBooty
Hoạt động văn hóa văn nghệ là một năm 2024
6 ngàys trước . bởi OutdatedScenery
Khắc phục lỗi phần mềm fot làm bị out game năm 2024
4 ngàys trước . bởi OvercastOutfield
Top phim xuyen khong hay nhat trung quoc năm 2024
3 ngàys trước . bởi BlissfulAbstinence

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Bản quyền © 2024 Inc.