Some collection classes are mutable. The methods that add, subtract, or rearrange their members in place, and don’t return a specific item, never return the collection instance itself but
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631
Some operations are supported by several object types; in particular, practically all objects can be compared for equality, tested for truth value, and converted to a string [with the function or the slightly different function]. The latter function is implicitly used when an object is written by the function
Truth Value Testing
Any object can be tested for truth value, for use in an or condition or as operand of the Boolean operations below
By default, an object is considered true unless its class defines either 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'] --> 637 method that 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'] --> 638 or 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'] --> 639 method that returns zero, when called with the object. Dưới đây là hầu hết các đối tượng tích hợp được coi là sai
constants defined to be false.
def bit_length[self]: 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 anddef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
38zero of any numeric type.
def bit_length[self]: 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
46empty sequences and collections.
def bit_length[self]: 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'] --> 642 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'] --> 638 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'] --> 655 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'] --> 656 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'] --> 657 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'] --> 658 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'] --> 662
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'] --> 663
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'] --> 664
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'] --> 656, 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'] --> 638
[3]
ghi chú
Đâ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 sai
Đâ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
def bit_length[self]: 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ậydef bit_length[self]: 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
Có tám thao tác so sánh trong Python. Tất cả chúng đều có cùng mức độ ưu tiên [cao hơn so với các phép toán Boolean]. So sánh có thể được xâu chuỗi tùy ý;
Bảng này tóm tắt các hoạt động so sánh
Hoạt động
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'] --> 674
hoàn toàn ít 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'] --> 675
nhỏ hơn hoặc 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'] --> 676
tuyệt đối 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'] --> 677
lớn hơn hoặc 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'] --> 678
công 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'] --> 679
không công 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'] --> 680
nhận dạng đố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'] --> 681
danh tính đối tượng phủ định
Các đối tượng thuộc các loại khác nhau, ngoại trừ các loại số khác nhau, không bao giờ so sánh bằng nhau. Toán 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'] --> 678 luôn được xác định nhưng đối với một số loại đối tượng [ví dụ: đối tượng lớp] tương đương với. Các toán 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'] --> 674,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 675,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 676 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'] --> 677 chỉ được xác định khi chúng có ý nghĩa;
Các thể hiện không giống nhau của một lớp thường được so sánh là không bằng nhau trừ khi lớp đó định nghĩa phương thức
Các thể hiện của một lớp không thể được sắp xếp theo thứ tự đối với các thể hiện khác của cùng một lớp hoặc các loại đối tượng khác, trừ khi lớp đó định nghĩa đủ các phương thức , , , và [nói chung là đủ, nếu bạn muốn ý nghĩa quy ước của
Không thể tùy chỉnh hành vi của toán tử và;
Hai thao tác nữa có cùng mức ưu tiên cú pháp và , được hỗ trợ bởi các loại hoặc triển khai phương thức
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 300
Các loại số — , ,
Có ba loại số riêng biệt. số nguyên, số dấu phẩy động và số phức. Ngoài ra, Booleans là một kiểu con của số nguyên. Số nguyên có độ chính xác không giới hạn. Số dấu phẩy động thường được triển khai bằng cách sử dụng double trong C; . Số phức có phần thực và phần ảo, mỗi phần là một số dấu chấm động. Để trích xuất các phần này từ một số phức z, hãy sử dụng
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 305 và
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 306. [Thư viện chuẩn bao gồm các loại số bổ sung , cho số hữu tỷ và , cho số dấu phẩy động với độ chính xác do người dùng xác định. ]
Các số được tạo bởi các chữ số hoặc là kết quả của các hàm và toán tử tích hợp. Các số nguyên không trang trí [bao gồm cả số hex, bát phân và nhị phân] mang lại số nguyên. Chữ số có chứa dấu thập phân hoặc dấu mũ mang lại số dấu phẩy động. Việc thêm
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 309 hoặc
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 310 vào một chữ số sẽ tạo ra một số ảo [một số phức có phần thực bằng 0] mà bạn có thể thêm vào một số nguyên hoặc dấu phẩy động để nhận được một số phức có phần thực và phần ảo
Python hỗ trợ đầy đủ số học hỗn hợp. khi một toán tử số học nhị phân có các toán hạng thuộc các kiểu số khác nhau, thì toán hạng có loại "hẹp hơn" được mở rộng sang toán hạng kia, trong đó số nguyên hẹp hơn dấu phẩy động, hẹp hơn phức hợp. So sánh giữa các số thuộc các loại khác nhau hoạt động như thể các giá trị chính xác của các số đó đang được so sánh.
Các hàm tạo , , và có thể được sử dụng để tạo các số thuộc một loại cụ thể
Tất cả các loại số [ngoại trừ phức tạp] đề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ú
tài liệu đầy đủ
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 314
tổng của x và y
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 315
sự khác biệt của x và y
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 316
sản phẩm của x và y
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 317
thương của x và y
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 318
thương số sàn của x và y
[1]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 319
phần còn lại của
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 317
[2]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 321
x phủ nhận
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 322
x không thay đổi
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 323
giá trị tuyệt đối hoặc độ lớn của x
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 325
x chuyển thành số nguyên
[3][6]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 327
x được chuyển đổi thành dấu phẩy động
[4][6]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 329
số phức có phần thực là phần ảo. tôi mặc định là không
[6]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 331
liên hợp của số phức c
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 332
cặp
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 333
[2]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 335
x lũy thừa y
[5]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 337
x lũy thừa y
[5]
ghi chú
Còn gọi là phép chia số nguyên. Giá trị kết quả là một số nguyên, mặc dù loại kết quả không nhất thiết phải là int. Kết quả luôn được làm tròn về phía âm vô cực.
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
38 là _______0_______42, _______51_______40 là _______51_______41, _______51_______42 là _______51_______41, và _______51_______44 là _________42Không dành cho số phức. Thay vào đó, hãy chuyển đổi thành float bằng cách sử dụng nếu thích hợp
Chuyển đổi từ dấu phẩy động sang số nguyên có thể làm tròn hoặc cắt ngắn như trong C;
float cũng chấp nhận các chuỗi “nan” và “inf” với tiền tố tùy chọn “+” hoặc “-” cho Không phải là Số [NaN] và vô cực dương hoặc âm
Python định nghĩa
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
49 và>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
50 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, như thường thấy đối với các ngôn ngữ lập trìnhCác chữ số được chấp nhận bao gồm các chữ 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
42 đến>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
53 hoặc bất kỳ mã Unicode tương đương nào [điểm mã với thuộc tính>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
54]Xem https. //www. unicode. tổ chức/Công khai/14. 0. 0/ucd/extracted/DerivedNumericType. txt để biết danh sách đầy đủ các điểm mã với thuộc tính
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
54
Tất cả các loại [ và ] cũng bao gồm các thao tác sau
Hoạt động
Kết quả
x cắt ngắn thành
x làm tròn đến n chữ số, làm tròn một nửa thành chẵn. Nếu n bị bỏ qua, nó mặc định là 0
lớn nhất = x
Đối với các hoạt động số bổ sung, hãy xem và mô-đun
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 phép toán bitwise nhị phân đều thấp hơn các phép toán số và cao hơn 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[] 371
bitwise hoặc của x và y
[4]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 372
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[] 373
bitwise và của x và y
[4]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 374
x dịch sang trái n bit
[1][2]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 375
x dịch sang phải n bit
[1][3]
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 376
các bit của x đảo ngược
ghi chú
Số lần thay đổi âm là bất hợp pháp và gây ra một sự gia tăng
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
78Dị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
78Thực hiện các tính toán 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[] 382 khác không, thì
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 383 là số nguyên dương duy nhất
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 384 sao cho
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 385. Tương tự, khi
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 323 đủ 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[] 387. Nếu
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 382 bằng 0, thì
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 383 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'] --> 642
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. Đây còn được gọi là số lượng dân số. Ví dụ
>>> 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"]
Mới trong phiên bản 3. 10
int. to_byte[độ dài=1, byteorder='big', *, signed=False]Trả về một mảng byte đại diện cho một số nguyên
>>> [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'
Số nguyên được biểu diễn bằng byte độ dài và mặc định là 1. An được nâng lên nếu số nguyên không thể biểu thị được với số byte đã cho
Đối số byteorder xác định thứ tự byte được sử dụng để biểu thị số nguyên và mặc định là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 392. Nếu thứ tự byte là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 392, thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu byteorder là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 394, thì byte quan trọng nhất nằm ở cuối mảng byte
Đối số đã ký xác định xem phần bù của hai có được sử dụng để biểu diễn số nguyên hay không. Nếu được ký 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'] --> 638 và một số nguyên âm được đưa ra, thì an được nâng lên. Giá trị mặc định cho đã ký 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'] --> 638
Các giá trị mặc định có thể được sử dụng để biến một số nguyên thành một đối tượng byte đơn một cách thuận tiện. Tuy nhiên, khi sử dụng các đối số mặc định, đừng cố chuyển đổi một giá trị lớn hơn 255, nếu không bạn sẽ nhận được một
>>> [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]
Mới trong phiên bản 3. 2
Đã thay đổi trong phiên bản 3. 11. Đã thêm các giá trị đối số mặc định cho
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 399 và
def bit_count[self]: return bin[self].count["1"]00. phương thức lớp int. từ_byte[byte , thứ tự byte='big', *, signed=False]
Trả về số nguyên được đại diện bởi mảng byte đã cho
>>> 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
Các byte đối số phải là một hoặc một byte tạo ra có thể lặp lại
Đối số byteorder xác định thứ tự byte được sử dụng để biểu thị số nguyên và mặc định là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 392. Nếu thứ tự byte là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 392, thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu byteorder là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 394, thì byte quan trọng nhất nằm ở cuối mảng byte. Để yêu cầu thứ tự byte gốc của hệ thống máy chủ, hãy sử dụng làm giá trị thứ tự byte
Đối số có dấu cho biết liệu phần bù hai có được sử dụng để biểu diễn số nguyên hay không
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 656 nếu đối tượng float là hữu hạn với giá trị nguyên và 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'] --> 638
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False
Hai phương pháp hỗ trợ chuyển đổi sang và từ các chuỗi thập lục phân. Vì số float của Python được lưu trữ bên trong dưới dạng số nhị phân, nên việc chuyển đổi số float thành hoặc từ chuỗi thập phân thường liên quan đến một lỗi làm tròn nhỏ. Ngược lại, các chuỗi thập lục phân cho phép biểu diễn và đặc tả chính xác các số dấu phẩy động. Điều này có thể hữu ích khi gỡ lỗi và trong công việc số
nổi. hex[]Trả về biểu diễn của số dấu phẩy động dưới dạng chuỗi thập lục phân. Đối với các số có dấu phẩy động hữu hạn, biểu diễn này sẽ luôn bao gồm một số ở đầu
def bit_count[self]: return bin[self].count["1"]12 và một số sau ____113_______13 và số mũphương thức lớp phao. từ hex[s]
Phương thức lớp để trả về số float được biểu thị bằng chuỗi thập lục phân s. Chuỗi s có thể có khoảng trắng ở đầu và cuối
Lưu ý rằng đó là một phương thức cá thể, trong khi đó là một phương thức lớp
Một chuỗi thập lục phân có dạ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'] --> 60
trong đó tùy chọn
def bit_count[self]: return bin[self].count["1"]16 có thể bằng cách hoặc là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 369 hoặc là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 370,
def bit_count[self]: return bin[self].count["1"]19 và
def bit_count[self]: return bin[self].count["1"]20 là các chuỗi chữ số thập lục phân và
def bit_count[self]: return bin[self].count["1"]21 là số nguyên thập phân có dấu ở đầu tùy chọn. Trường hợp không đáng kể và phải có ít nhất một chữ số thập lục phân trong số nguyên hoặc phân số. Cú pháp này tương tự như cú pháp quy định tại mục 6. 4. 4. 2 của tiêu chuẩn C99 và cả cú pháp được sử dụng trong Java 1. 5 trở đi. Cụ thể, đầu ra của có thể sử dụng dưới dạng ký tự dấu phẩy động thập lục phân trong mã C hoặc Java và các chuỗi thập lục phân được tạo bởi ký tự định dạng __113_______23 của C hoặc ____113_______24 của Java được chấp nhận bởi
Lưu ý rằng số mũ được viết dưới dạng thập phân chứ không phải thập lục phân và nó mang lại sức mạnh của 2 để nhân hệ số. Ví dụ: chuỗi thập lục phân
def bit_count[self]: return bin[self].count["1"]26 đại diện cho số dấu phẩy động
def bit_count[self]: return bin[self].count["1"]27 hoặc
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'] --> 61
Áp dụng chuyển đổi ngược lại cho
def bit_count[self]: return bin[self].count["1"]28 sẽ cho một chuỗi thập lục phân khác đại diện cho cùng một 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'] --> 62
Băm các loại số
Đối với các số
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 382 và
def bit_count[self]: return bin[self].count["1"]31, có thể thuộc các loại khác nhau, yêu cầu là ____113_______32 bất cứ khi nào
def bit_count[self]: return bin[self].count["1"]33 [xem tài liệu về phương pháp để biết thêm chi tiết]. Để dễ triển khai và hiệu quả trên nhiều loại số [bao gồm , và ] Hàm băm của Python cho các loại số dựa trên một hàm toán học duy nhất được xác định cho bất kỳ số hữu tỷ nào và do đó áp dụng cho tất cả các trường hợp của và , và tất cả các trường hợp hữu hạn . Về cơ bản, hàm này được cho bởi modulo rút gọn
def bit_count[self]: return bin[self].count["1"]43 cho số nguyên tố cố định
def bit_count[self]: return bin[self].count["1"]43. Giá trị của
def bit_count[self]: return bin[self].count["1"]43 được cung cấp cho Python dưới dạng thuộc tính
def bit_count[self]: return bin[self].count["1"]46 của
Chi tiết triển khai CPython. 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
Dưới đây là các quy tắc chi tiết
Nếu
def bit_count[self]: return bin[self].count["1"]
50 là một số hữu tỉ không âm vàdef bit_count[self]: return bin[self].count["1"]
51 không chia hết chodef bit_count[self]: return bin[self].count["1"]
43, hãy xác địnhdef bit_count[self]: return bin[self].count["1"]
53 làdef bit_count[self]: return bin[self].count["1"]
54, trong đódef bit_count[self]: return bin[self].count["1"]
55 cho số nghịch đảo củadef bit_count[self]: return bin[self].count["1"]
51 theo modulodef bit_count[self]: return bin[self].count["1"]
43Nếu
def bit_count[self]: return bin[self].count["1"]
50 là một số hữu tỉ không âm vàdef bit_count[self]: return bin[self].count["1"]
51 chia hết chodef bit_count[self]: return bin[self].count["1"]
43 [nhưngdef bit_count[self]: return bin[self].count["1"]
61 thì không] thìdef bit_count[self]: return bin[self].count["1"]
51 không có modulo nghịch đảodef bit_count[self]: return bin[self].count["1"]
43 và quy tắc trên không áp dụng;Nếu
def bit_count[self]: return bin[self].count["1"]
50 là một số hữu tỷ âm, hãy xác địnhdef bit_count[self]: return bin[self].count["1"]
53 làdef bit_count[self]: return bin[self].count["1"]
68. Nếu hàm băm kết quả là>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
41, hãy thay thế nó bằngdef bit_count[self]: return bin[self].count["1"]
70Các giá trị cụ thể
def bit_count[self]: return bin[self].count["1"]
65 vàdef bit_count[self]: return bin[self].count["1"]
72 được sử dụng làm giá trị băm cho vô cực dương hoặc vô cực âm [tương ứng]Đối với một số
def bit_count[self]: return bin[self].count["1"]
74, các giá trị băm của phần thực và phần ảo được kết hợp bằng cách tính toándef bit_count[self]: return bin[self].count["1"]
75, rút gọn modulodef bit_count[self]: return bin[self].count["1"]
76 để nó nằm trong ____113_______77. Một lần nữa, nếu kết quả là>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
41, nó sẽ được thay thế bằngdef bit_count[self]: return bin[self].count["1"]
70
Để làm rõ các quy tắc trên, đây là một số mã Python ví dụ, tương đương với hàm băm tích hợp, để tính toán hàm băm của một số hữu tỷ, 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'] --> 63
Các loại trình lặp
Python hỗ trợ khái niệm lặp qua các vùng chứa. Điều này được thực hiện bằng hai phương pháp riêng biệt; . Các trình tự, được mô tả chi tiết hơn bên dưới, luôn hỗ trợ các phương pháp lặp
Một phương thức cần được xác định cho các đối tượng vùng chứa để cung cấp hỗ trợ
vùng chứa. __iter__[]Trả lại một đối tượng. Đối tượng được yêu cầu hỗ trợ giao thức iterator được mô tả bên dưới. Nếu một vùng chứa hỗ trợ các kiểu lặp khác nhau, thì có thể cung cấp các phương thức bổ sung để yêu cầu cụ thể các trình vòng lặp cho các kiểu lặp đó. [Ví dụ về một đối tượng hỗ trợ nhiều hình thức lặp lại 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. ] Phương thức này tương ứng với vị trí của cấu trúc kiểu cho các đối tượng Python trong API Python/C
Bản thân các đối tượng lặp được yêu cầu hỗ trợ hai phương thức sau, cùng nhau tạo thành giao thức lặp
trình lặp. __iter__[]Trả lại chính đối tượng. Điều này là bắt buộc để cho phép sử dụng cả bộ chứa và bộ lặp với câu lệnh và. Phương thức này tương ứng với vị trí của cấu trúc kiểu cho các đối tượng Python trong API Python/C
trình lặp. __next__[]Trả lại mục tiếp theo từ. Nếu không có mục nào khác, hãy đưa ra ngoại lệ. Phương thức này tương ứng với vị trí của cấu trúc kiểu cho các đối tượng Python trong API Python/C
Python định nghĩa một số đối tượng trình lặp để hỗ trợ phép lặp qua các loại trình tự chung và cụ thể, từ điển và các dạng chuyên biệt hơn khác. Các loại cụ thể không quan trọng ngoài việc triển khai giao thức lặp
Khi một phương thức của trình vòng lặp tăng lên, nó phải tiếp tục làm như vậy trong các lần gọi tiếp theo. Việc triển khai không tuân theo thuộc tính này được coi là bị hỏng
Các loại máy phát điện
Python cung cấp một cách thuận tiện để triển khai giao thức lặp. Nếu phương thức
def bit_count[self]: return bin[self].count["1"]90 của đối tượng vùng chứa được triển khai như một trình tạo, thì nó sẽ tự động trả về một đối tượng trình vòng lặp [về mặt kỹ thuật, một đối tượng trình tạo] cung cấp ___113_______90 và các phương thức. Thông tin thêm về máy phát điện có thể được tìm thấy trong
Các loại trình tự — , ,
Có ba loại trình tự cơ bản. danh sách, bộ dữ liệu và đối tượng phạm vi. Các loại trình tự bổ sung được điều chỉnh để xử lý và được mô tả trong các phần dành riêng
Hoạt động tuần tự phổ biến
Các hoạt động trong bảng sau được hỗ trợ bởi hầu hết các loại trình tự, cả có thể thay đổi và không thể thay đổi. ABC được cung cấp để giúp triển khai chính xác các thao tác này trên các loại trình tự tùy chỉnh dễ dàng hơn
Bảng này liệt kê các hoạt động trình tự được sắp xếp theo mức độ ưu tiên tăng dần. Trong bảng, s và t là các chuỗi cùng loại, n, i, j và k là các số nguyên và x là một đối tượng tùy ý đáp ứng mọi hạn chế về loại và giá trị do s áp đặt
Các 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'] --> 698 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'] --> 699 có cùng mức độ ưu tiên như các phép toán so sánh. Các phép toán
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 369 [nối] và
>>> [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 [lặp lại] có cùng mức độ ưu tiên như các phép toán số tương ứng.
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'] --> 656 nếu một mục 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'] --> 638
[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'] --> 638 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'] --> 656
[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
nối của s và 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 hoặc
>>> [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
tương đương với việc thêm s vào chính nó n lần
[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
mục thứ i của s, gốc 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
lát s từ i đến 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
lát s từ i đến j với bước 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
chiều dài của 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
mục nhỏ nhất của 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
mục lớn nhất của 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ú
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 anddef bit_length[self]: 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 testingdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
4Values 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 asdef bit_length[self]: 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; considerdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
5What 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 waydef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
6Further explanation is available in the FAQ entry
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 stilldef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
42The 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 ordef bit_length[self]: 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, usedef bit_length[self]: 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 ordef bit_length[self]: 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 emptyThe 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 ordef bit_length[self]: 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]. Note, k cannot be zero. If k isdef bit_length[self]: 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 likedef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
55Concatenating 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. Để có chi phí thời gian chạy tuyến tính, bạn phải chuyển sang một trong các lựa chọn thay thế bên dưới
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
Some sequence types [such as ] only support item sequences that follow specific patterns, and hence don’t support sequence concatenation or repetition
>>> [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. These arguments allow efficient searching of subsections of the sequence. 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
các phần tử của
>>> [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 được thay thế bằng các phần tử của 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
xóa các phần tử của
>>> [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 khỏi danh sá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'83
nối x vào cuối dãy [giống như
>>> [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
xóa tất cả các mục khỏi s [giống như
>>> [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
tạo một bản sao nông của s [giống như
>>> [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 hoặc
>>> [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
kéo dài s với nội dung của t [phần lớn giống như
>>> [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
cập nhật s với nội dung được lặp lại n lần
[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
chèn x vào s tại chỉ số được cung cấp bởi i [giống như
>>> [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 hoặc
>>> [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
truy xuất mục tại i và cũng xóa mục đó khỏi 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
xóa mục đầu tiên khỏi s trong đó
>>> [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 bằng 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
đảo ngược các mục của s tại chỗ
[4]
ghi chú
t phải có cùng độ dài với lát cắt mà nó đang thay thế
Đối số tùy chọn i mặc định là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
41, do đó, theo mặc định, mục cuối cùng được xóa và trả lại>>> [65].to_bytes[] b'A'
01 tăng khi không tìm thấy x trong sPhương pháp
>>> [65].to_bytes[] b'A'
03 sửa đổi trình tự tại chỗ để tiết kiệm không gian khi đảo ngược một trình tự lớn. Để nhắc nhở người dùng rằng nó hoạt động theo tác dụng phụ, nó không trả về trình tự đảo ngược>>> [65].to_bytes[] b'A'
04 và>>> [65].to_bytes[] b'A'
05 được đưa vào để thống nhất với giao diện của các 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 không phải là một phần của ABC, nhưng hầu hết các lớp trình tự có thể thay đổi cụ thể đều cung cấp nóMới trong phiên bản 3. 3. ______120_______04 và phương thức
>>> [65].to_bytes[] b'A'
05.Giá trị n là một số nguyên hoặc một đối tượng thực hiện. Giá trị 0 và âm của n xóa chuỗi. Các mục trong chuỗi không được sao chép;
danh sách
Danh sách là các chuỗi có thể thay đổi, thường được sử dụng để lưu trữ các bộ sưu tập các mục đồng nhất [trong đó mức độ tương tự chính xác sẽ thay đổi tùy theo ứng dụng]
lớp danh sách[[có thể lặp lại]]Danh sách có thể được xây dựng theo nhiều cách
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
49Sử dụng dấu ngoặc vuông, phân tách các mục bằng dấu phẩy.
>>> [65].to_bytes[] b'A'
15,>>> [65].to_bytes[] b'A'
16Sử dụng hiểu danh sách.
>>> [65].to_bytes[] b'A'
17Using 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'] --> 649
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'] --> 674 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'] --> 631 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'] --> 656, 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
48Using a trailing comma for a singleton tuple.
>>> [65].to_bytes[] b'A'
40 or>>> [65].to_bytes[] b'A'
41Separating items with commas.
>>> [65].to_bytes[] b'A'
42 or>>> [65].to_bytes[] b'A'
43Sử dụng tích hợp.
>>> [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'] --> 648
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]. If the step 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'] --> 655. 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'] --> 642. 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
Ranges containing absolute values larger than are permitted but some features [such as ] may raise
Range examples
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 67
Ranges implement all of the sequence operations except concatenation and repetition [due to the fact that range objects can only represent sequences that follow a strict pattern and repetition and concatenation will usually violate that pattern]
startThe 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'] --> 642 if the parameter was not supplied]stop
The value of the stop parameter
stepThe 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'] --> 655 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'] --> 68
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'] --> 678 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'] --> 679 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'
96Double quotes.
>>> [65].to_bytes[] b'A'
97Triple 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
Các chuỗi ký tự là một phần của một biểu thức và chỉ có khoảng trắng giữa chúng sẽ được chuyển đổi hoàn toàn thành một chuỗi ký tự đơn. 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
Cũng không có loại chuỗi có thể thay đổi, nhưng hoặc có thể được sử dụng để xây dựng chuỗi từ nhiều đoạn một cách hiệu quả
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'] --> 633 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'] --> 69
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'13str. 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']Return the string encoded to
encoding defaults 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]36; see for possible values
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. 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,
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 and any other name registered via . See for details
For performance reasons, the value of errors is not checked for validity unless an encoding error actually occurs, is enabled or a is used
Changed in version 3. 1. Added support for keyword arguments.
Changed in version 3. 9. The value of the errors argument is now checked in and in .
str. 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'] --> 656 if the string 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'] --> 638. suffix can also be a tuple of suffixes to look for. With optional start, test beginning at that position. With optional end, stop comparing at that positionstr. expandtabs[tabsize=8]
Return a copy of the string where all tab characters are replaced by one or more spaces, depending on the current column and the given tab size. Tab positions occur every tabsize characters [default is 8, giving tab positions at columns 0, 8, 16 and so on]. To expand the string, the current column is set to zero and the string is examined character by character. 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[] 30str. 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[] 341 if sub is not found
Note
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[] 31str. 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'] --> 650. 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[] 32
See for a description of the various formatting options that can be specified in format strings
Note
Khi định dạng một số [, , và các lớp con] với loại
def bit_count[self]: return bin[self].count["1"]51 [ví dụ:.
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 . Điều này hữu ích nếu ví dụ
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 là một lớp con dict
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 33
Mới trong phiên bản 3. 2
str. index[sub[ , start[ , end]]]Thích , nhưng tăng khi không tìm thấy chuỗi con
str. 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'] --> 656 nếu tất cả các ký tự trong chuỗi là chữ và số và có ít nhất một ký tự, 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'] --> 638. Một ký tự
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 là chữ và số nếu một trong 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'] --> 656.
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 hoặ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]83str. 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'] --> 656 nếu tất cả các ký tự trong chuỗi là chữ cái và có ít nhất một ký tự, 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'] --> 638. Các ký tự chữ cái là những ký tự được định nghĩa trong cơ sở dữ liệu ký tự Unicode là “Chữ cái”, tôi. e. , những người có thuộc tính danh mục chung là một trong số “Lm”, “Lt”, “Lu”, “Ll”, hoặc “Lo”. Lưu ý rằng thuộc tính này khác với thuộc tính “Alphabetic” được xác định trong Tiêu chuẩn Unicodestr. 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'] --> 656 nếu chuỗi trống hoặc tất cả các ký tự 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'] --> 638. Các ký tự ASCII có các điểm mã trong phạm vi U+0000-U+007F
Mới trong phiên bản 3. 7
str. hệ thập phâ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'] --> 656 nếu tất cả các ký tự trong chuỗi là ký tự thập phân và có ít nhất một ký tự, 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'] --> 638. Các ký tự thập phân là những ký tự có thể được sử dụng để tạo thành các số trong cơ số 10, e. g. U+0660, CHỮ SỐ Ả Rập-INDIC. Chính thức, một ký tự thập phân là một ký tự trong Danh mục chung Unicode “Nd”str. 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'] --> 656 nếu tất cả các ký tự trong chuỗi là chữ số và có ít nhất một ký tự, 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'] --> 638. Chữ số bao gồm các ký tự thập phân và chữ số cần xử lý đặc biệt, chẳng hạn như chữ số chỉ số trên tương thích. Điều này bao gồm các chữ số không thể được sử dụng để tạo thành số trong cơ số 10, như số Kharosthi. Chính thức, một chữ số là một ký tự có giá trị thuộc tính Numeric_Type=Digit hoặc Numeric_Type=Decimalstr. mã định danh[]
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'] --> 656 nếu chuỗi là mã định danh hợp lệ theo định nghĩa ngôn ngữ, mục
Gọi để kiểm tra xem chuỗ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]94 có phải là mã định danh dành riêng hay không, chẳng hạn như và
Ví dụ
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 34str. bộ 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'] --> 656 nếu tất cả các ký tự viết hoa trong chuỗi là chữ thường và có ít nhất một ký tự viết hoa, ngược lại là _________38str. số[]
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'] --> 656 nếu tất cả các ký tự trong chuỗi là ký tự số và có ít nhất một ký tự, 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'] --> 638. Các ký tự số bao gồm các ký tự chữ số và tất cả các ký tự có thuộc tính giá trị số Unicode, e. g. U+2155, PHÂN SỐ Thô tục MỘT PHẦN NĂM. Về hình thức, các ký tự số là những ký tự có giá trị thuộc tính Numeric_Type=Digit, Numeric_Type=Decimal hoặc Numeric_Type=Numericstr. có thể in đượ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'] --> 656 nếu tất cả các ký tự trong chuỗi có thể in được hoặc chuỗi 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'] --> 638. Các ký tự không in được là những ký tự được định nghĩa trong cơ sở dữ liệu ký tự Unicode là “Khác” hoặc “Dấu phân cách”, ngoại trừ khoảng trống ASCII [0x20] được coi là có thể in được. [Lưu ý rằng các ký tự có thể in được trong ngữ cảnh này là những ký tự không được thoát khi được gọi trên một chuỗi. Nó không liên quan đến việc xử lý các chuỗi được ghi vào hoặc. ]str. 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'] --> 656 nếu chỉ có ký tự khoảng trắng trong chuỗi và có ít nhất một ký tự, 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'] --> 638
Một ký tự là khoảng trắng nếu trong cơ sở dữ liệu ký tự Unicode [xem ], loại chung của nó là
>>> 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'] 1671168009 [“Dấu phân cách, dấu cách”] hoặc loại hai chiều của nó là một trong số
>>> 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'] 1671168010,
>>> 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'] 1671168011 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'] 1671168012str. 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'] --> 656 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. 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'] --> 638 nếu khôngstr. ă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'] --> 656 nếu tất cả các ký tự viết hoa trong chuỗi là chữ hoa và có ít nhất một ký tự viết 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'] --> 638
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 35str. tham gia[có thể lặp lại]
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'13str. 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'] --> 631, 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[] 36
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[] 37static 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'] --> 631. 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'] --> 631 in the resultstr. 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 , /]Nếu chuỗi bắt đầu bằng chuỗi tiền tố, hãy trả về
>>> 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'] 1671168025. Otherwise, return a copy of the original string
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 38
New in version 3. 9
str. removesuffix[suffix , /]Nếu chuỗi kết thúc bằng chuỗi hậu tố và hậu tố đó không trống, hãy trả về
>>> 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'] 1671168026. Otherwise, return a copy of the original string
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 39
New in version 3. 9
str. thay thế[cũ , mới[, count]]Return a copy of the string with all occurrences of substring old replaced by new. Nếu số lượng đối số tùy chọn được cung cấp, chỉ những lần xuất hiện đầu tiên được thay thế
str. rfind[phụ[ , start[, end]]]Trả về chỉ số cao nhất trong chuỗi nơi tìm thấy chuỗi con sub, sao cho sub đó được chứa trong
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. Các đối số tùy chọn bắt đầu và kết thúc được diễn giải như trong ký hiệu lát cắt. Trả lại
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 341 khi thất bạistr. rindex[sub[ , start[, end]]]
Like nhưng tăng khi không tìm thấy chuỗi con sub
str. rjust[chiều rộng[ , fillchar]]Trả về chuỗi được căn phải trong một chuỗi có chiều dài chiều rộng. Việc đệm được thực hiện bằng cách sử dụng ký tự điền được chỉ định [mặc định là không gian ASCII]. Chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
>>> [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'13str. phân vùng[sep]
Tách chuỗi ở lần xuất hiện cuối cùng của sep và trả về 3 bộ chứa phần trước dấu phân cách, chính dấu phân cách và phần sau dấu phân cách. Nếu không tìm thấy dấu tách, hãy trả về 3-tuple chứa hai chuỗi trống, theo sau là chính chuỗi đó
str. rsplit[sep=Không có, maxsplit=- 1]Trả về danh sách các từ trong chuỗi, sử dụng sep làm chuỗi phân cách. Nếu maxsplit được đưa ra, thì tối đa các phần tách maxsplit được thực hiện, những phần ngoài cùng bên phải. Nếu sep không được chỉ định 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'] --> 631, thì bất kỳ chuỗi khoảng trắng nào cũng là dấu phân cách. Ngoại trừ tách từ bên phải, hoạt động như được mô tả chi tiết bên dướistr. rstrip[[ký tự]]
Trả về một bản sao của chuỗi đã xóa các ký tự ở cuối. Đối số ký tự là một chuỗi chỉ định bộ ký tự sẽ bị xóa. 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'] --> 631, 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
Xem một phương thức sẽ loại bỏ một chuỗi hậu tố thay vì tất cả một bộ ký tự. Ví dụ
def bit_count[self]: return bin[self].count["1"]1str. tách[sep=Không có, maxsplit=- 1]
Trả về danh sách các từ trong chuỗi, sử dụng sep làm chuỗi phân cách. Nếu maxsplit được đưa ra, thì tối đa việc tách maxsplit được thực hiện [do đó, danh sách sẽ có tối đ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'] 1671168037 phần tử]. Nếu maxsplit không được chỉ định hoặc
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 341, thì không có giới hạn về số lần phân tách [tất cả các lần phân tách có thể được thực hiện]
Nếu sep được đưa ra, các dấu phân cách liên tiếp không được nhóm lại với nhau và được coi là phân cách các chuỗi trống [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'] 1671168039 trả về
>>> 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'] 1671168040]. Đối số sep có thể bao gồm nhiều ký tự [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'] 1671168041 trả về
>>> 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'] 1671168042]. Việc tách một chuỗi rỗng bằng một dấu tách được chỉ định sẽ trả về
>>> 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'] 1671168043
Ví dụ
def bit_count[self]: return bin[self].count["1"]2
Nếu sep không được chỉ định hoặc 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'] --> 631, một thuật toán phân tách khác sẽ được áp dụng. các khoảng trắng liên tiếp được coi là một dấu phân cách duy nhất và kết quả sẽ không chứa chuỗi trống ở đầu hoặc cuối nếu chuỗi có khoảng trắng ở đầu hoặc cuối. Do đó, việc tách một chuỗi rỗng hoặc một chuỗi chỉ bao gồm khoảng trắng bằng dấu phân cá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'] --> 631 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'] --> 649
Ví dụ
def bit_count[self]: return bin[self].count["1"]3str. đường phân chia[keepends=Sai]
Trả về danh sách các dòng trong chuỗi, phá vỡ ranh giới 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
Phương pháp này phân chia trên các ranh giới dòng sau. Đặc biệt, các ranh giới là một siêu tập hợp của
đại diện
Sự miêu tả
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'] 1671168049
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'] 1671168050 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'] 1671168051
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'] 1671168052 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'] 1671168053
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'] 1671168054
Trình tách tệp
>>> 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'] 1671168055
Tách nhóm
>>> 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'] 1671168056
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'] 1671168057
Dòng tiếp theo [Mã kiểm soát C1]
>>> 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'] 1671168058
Dấu phân cách 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'] 1671168059
Dấu phân cách đoạn văn
Đã thay đổi trong phiên bản 3. 2. ______124_______50 và
>>> 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'] 1671168052 được thêm vào danh sách ranh giới đường.
Ví dụ
def bit_count[self]: return bin[self].count["1"]4
Không giống như khi một chuỗi phân cách sep được đưa ra, phương thức này trả về một danh sách trống cho chuỗi trống và ngắt dòng ở cuối không dẫn đến một dòng thừa
def bit_count[self]: return bin[self].count["1"]5
Để so sánh,
>>> 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'] 1671168063 cho
def bit_count[self]: return bin[self].count["1"]6str. startswith[tiền 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'] --> 656 nếu chuỗi bắt đầu bằng tiền tố, ngược lạ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'] --> 638. tiền tố cũng có thể là một bộ tiền tố cần tìm. Với bắt đầu tùy chọn, chuỗi kiểm tra bắt đầu ở vị trí đó. Với kết thúc tùy chọn, dừng so sánh chuỗi tại vị trí đóstr. dải[[ký tự]]
Trả về một bản sao của chuỗi đã xóa các ký tự đầu và cuối. Đối số ký tự là một chuỗi chỉ định bộ ký tự sẽ bị xóa. Nếu bỏ qua 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'] --> 631, đối số ký tự mặc định xóa khoảng trắng. Đối số ký tự không phải là tiền tố hoặc hậu tố;
def bit_count[self]: return bin[self].count["1"]7
Các giá trị đối số ký tự đầu và cuối ngoài cùng bị loại bỏ khỏi chuỗi. Characters are removed from the leading end until reaching a string character that is not contained in the set of characters in chars. Một hành động tương tự diễn ra ở cuối đuôi. Ví dụ
def bit_count[self]: return bin[self].count["1"]8str. hoán đổi[]
Trả về một bản sao của chuỗi với các ký tự hoa được chuyển đổi thành chữ thường và ngược lại. Lưu ý rằng điều đó không nhất thiết đúng là
>>> 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'] 1671168067str. tiêu đề[]
Trả về phiên bản có tiêu đề của chuỗi trong đó các từ bắt đầu bằng ký tự viết hoa và các ký tự còn lại là chữ thường
Ví dụ
def bit_count[self]: return bin[self].count["1"]9
Thuật toán sử dụng một định nghĩa đơn giản không phụ thuộc vào ngôn ngữ của một từ dưới dạng các nhóm chữ cái liên tiếp. Định nghĩa hoạt động trong nhiều ngữ cảnh nhưng nó có nghĩa là dấu nháy đơn trong các từ rút gọn và sở hữu tạo thành ranh giới từ, có thể không phải là kết quả mong muốn
>>> [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
Hàm này không gặp sự cố này vì nó chỉ tách các từ trên khoảng trắng
Ngoài ra, 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
>>> [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'1str. dịch[bảng]
Trả về một bản sao của chuỗi trong đó mỗi ký tự đã được ánh xạ qua bảng dịch đã cho. Bảng phải là một đối tượng thực hiện lập chỉ mục thông qua
>>> 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'] 1671168069, thường là một hoặc. Khi được lập chỉ mục bởi một thứ tự Unicode [một số nguyên], đối tượng bảng có thể thực hiện bất kỳ thao tác nào sau đây. trả về một thứ tự Unicode hoặc một chuỗi, để ánh xạ ký tự tới một hoặc nhiều ký tự khác;
Bạn có thể sử dụng để tạo bản đồ dịch từ ánh xạ ký tự sang ký tự ở các định dạng khác nhau
Xem thêm mô-đun để biết cách tiếp cận linh hoạt hơn đối với ánh xạ ký tự tùy chỉnh
str. trên[]Trả về một bản sao của chuỗi với tất cả các ký tự được viết hoa được chuyển đổi thành chữ hoa. Lưu ý rằ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'] 1671168074 có thể 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'] --> 638 nế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]94 chứa các ký tự không được viết hoa hoặc nếu danh mục Unicode của [các] ký tự kết quả không phải là “Lu” [Chữ cái, chữ hoa], mà là e. g. “Lt” [Thư, tựa đề]
The uppercasing algorithm used is described in section 3. 13 của Tiêu chuẩn Unicode
str. 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
>>> 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'] 1671168077 chữ số để tạo chuỗi có chiều dài chiều rộng. Tiền tố dấu hiệu ở đầ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'] 1671168078/
>>> 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'] 1671168079] được xử lý bằng cách chèn phần đệm sau ký tự dấu hiệu thay vì trước. Chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
>>> [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
Ví dụ
>>> [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]
Định dạng chuỗi kiểu 26
Note
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]. Sử dụng giao diện mới hơn hoặc có thể giúp tránh những lỗi này. Mỗi lựa chọn thay thế này cung cấp sự đánh đổi và lợi ích của riêng chúng về tính đơn giản, tính linh hoạt và/hoặc khả năng mở rộng
String objects have one unique built-in operation. 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'] 1671168083 [mô-đun]. Điều này còn được gọi là định dạng chuỗi 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'] 1671168084 [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'] 1671168083 ở định dạng được thay thế bằng 0 hoặc nhiều phần tử 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'] 1671168086 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. Nếu không, các giá trị phải là một bộ có số mục chính xác được chỉ định bởi chuỗi định dạng hoặc một đối tượng ánh xạ đơn lẻ [ví dụ: từ điển]
Trình xác định chuyển đổi chứa hai hoặc nhiều ký tự và có các thành phần sau, phải xảy ra theo thứ tự này
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, đánh dấu sự bắt đầu của trình xác địnhMapping 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]Cờ chuyển đổi [tùy chọn], ảnh hưởng đến kết quả của một số loại chuyển đổi
Độ rộng trường tối thiểu [tùy chọn]. Nếu được chỉ định là
>>> 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 [dấu hoa thị], chiều rộng thực tế được đọc từ phần tử tiếp theo của bộ giá trị và đối tượng cần chuyển đổi xuất hiện sau chiều rộng trường tối thiểu và độ chính xác tùy chọnĐộ chính xác [tùy chọn], được cho dưới 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
90 [dấu chấm] theo sau là độ chính xác. Nếu được chỉ định là>>> 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 [dấu hoa thị], thì độ chính xác thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu theo giá trị và giá trị cần chuyển đổi xuất hiện sau độ chính xácCông cụ sửa đổi độ dài [tùy chọn]
loại chuyển đổi
Khi đối số bên phải là từ điển [hoặc loại ánh xạ khác], thì các định dạng trong chuỗi 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'] 1671168087. Phím ánh xạ chọn giá trị được định dạng từ ánh xạ. Ví dụ
>>> [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
Trong trường hợp này, không có bộ chỉ định
>>> [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 nào có thể xuất hiện ở định dạng [vì chúng yêu cầu danh sách tham số tuần tự]
Các ký tự cờ chuyển đổi là
Lá cờ
Nghĩ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'] 1671168094
Việc chuyển đổi giá trị sẽ sử dụng “hình thức thay thế” [được định nghĩa bên dướ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'] 1671168077
Chuyển đổi sẽ được đệm bằng 0 cho các giá trị số
>>> 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'] 1671168079
Giá trị chuyển đổi được điều chỉnh trái [ghi đè chuyển đổ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'] 1671168077 nếu cả hai đều được cung cấp]
>>> 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'] 1671168098
[khoảng trắng] Nên để trống trước số dương [hoặc chuỗi trống] được tạo bởi chuyển đổi đã ký
>>> 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'] 1671168078
Một ký tự dấ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'] 1671168078 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'] 1671168079] sẽ đứng trước chuyển đổi [ghi đè cờ “dấu cách”]
Công cụ sửa đổi độ dà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 n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 341 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 but raises when the subsequence sub 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. 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'] --> 656 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'] --> 638. 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í đó. Với đầu cuối tùy chọn, dừng so sánh tại vị trí đó
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
Bạn có thể sử dụng phương pháp để tạo bảng dịch
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'] --> 631 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
Note
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
Note
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'] --> 631, 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
Note
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
Note
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'] --> 631, any subsequence consisting solely of ASCII whitespace is a separator. Except for splitting from the right, behaves like which is described in detail belowbytes. rstrip[[chars]]bytearray. rstrip[[chars]]
Return a copy of the sequence with specified 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'] --> 631, 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
Note
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'] 1671168037 elements]. If maxsplit is not specified or is
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 341, 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[] False27 returns
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False28]. The sep argument may consist of a multibyte sequence [for example,
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False29 returns
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False30]. Splitting an empty sequence with a specified separator returns
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False31 or
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False32 depending on the type of object being split. The sep argument may be any
Ví dụ
>>> [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'] --> 631, 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'] --> 649
Ví dụ
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]0bytes. 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'] --> 631, 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
Note
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[]Return a copy of the sequence with each byte interpreted as an ASCII character, and the first byte capitalized and the rest lowercased. Non-ASCII byte values are passed through unchanged
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
bytes. expandtabs[tabsize=8]bytearray. expandtabs[tabsize=8]Return a copy of the sequence where all ASCII tab characters are replaced by one or more ASCII spaces, depending on the current column and the given tab size. Tab positions occur every tabsize bytes [default is 8, giving tab positions at columns 0, 8, 16 and so on]. To expand the sequence, the current column is set to zero and the sequence is examined byte by byte. If the byte is an ASCII tab character [
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False36], 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 current byte is an ASCII newline [
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False37] or carriage return [
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False38], it is copied and the current column is reset to zero. Any other byte value is copied unchanged and the current column is incremented by one regardless of how the byte value is represented when printed
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
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
bytes. isalnum[]bytearray. 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'] --> 656 if all bytes in the sequence are alphabetical ASCII characters or ASCII decimal digits and the sequence is not 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'] --> 638 otherwise. Alphabetic ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False41. ASCII decimal digits are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False42
Ví dụ
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]3bytes. isalpha[]bytearray. 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'] --> 656 if all bytes in the sequence are alphabetic ASCII characters and the sequence is not 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'] --> 638 otherwise. 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[] False41
Ví dụ
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]4byte. isascii[]bytearray. 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'] --> 656 if the sequence is empty or all bytes in the sequence 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'] --> 638 otherwise. ASCII bytes are in the range 0-0x7F
Mới trong phiên bản 3. 7
bytes. isdigit[]bytearray. 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'] --> 656 if all bytes in the sequence are ASCII decimal digits and the sequence is not 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'] --> 638 otherwise. ASCII decimal digits are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False42
Ví dụ
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]5bytes. islower[]bytearray. 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'] --> 656 if there is at least one lowercase ASCII character in the sequence and no uppercase ASCII characters,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise
Ví dụ
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
Lowercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False53. Uppercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False54bytes. isspace[]bytearray. 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'] --> 656 if all bytes in the sequence are ASCII whitespace and the sequence is not 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'] --> 638 otherwise. ASCII whitespace characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False57 [space, tab, newline, carriage return, vertical tab, form feed]bytes. istitle[]bytearray. istitle[]
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'] --> 656 if the sequence is ASCII titlecase and the sequence is not 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'] --> 638 otherwise. See for more details on the definition of “titlecase”
Ví dụ
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]7bytes. isupper[]bytearray. 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'] --> 656 if there is at least one uppercase alphabetic ASCII character in the sequence and no lowercase ASCII characters,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise
Ví dụ
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
Lowercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False53. Uppercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False54bytes. lower[]bytearray. lower[]
Return a copy of the sequence with all the uppercase ASCII characters converted to their corresponding lowercase counterpart
Ví dụ
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
Lowercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False53. Uppercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False54
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
bytes. splitlines[keepends=False]bytearray. splitlines[keepends=False]Return a list of the lines in the binary sequence, breaking at ASCII line boundaries. This method uses the approach to splitting lines. Line breaks are not included in the resulting list unless keepends is given and true
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'] 167116800
Không giống như khi một chuỗi phân cách sep được đưa ra, phương thức này trả về một danh sách trống cho chuỗi trống và ngắt dòng ở cuối không dẫn đến một dòng thừ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'] 167116801bytes. swapcase[]bytearray. swapcase[]
Return a copy of the sequence with all the lowercase ASCII characters converted to their corresponding uppercase counterpart and vice-versa
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'] 167116802
Lowercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False53. Uppercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False54
Unlike , it is always the case that
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False71 for the binary versions. Case conversions are symmetrical in ASCII, even though that is not generally true for arbitrary Unicode code points
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
bytes. title[]bytearray. title[]Return a titlecased version of the binary sequence where words start with an uppercase ASCII character and the remaining characters are lowercase. Uncased byte values are left unmodified
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'] 167116803
Lowercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False53. Uppercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False54. All other byte values are uncased
Thuật toán sử dụng một định nghĩa đơn giản không phụ thuộc vào ngôn ngữ của một từ dưới dạng các nhóm chữ cái liên tiếp. Định nghĩa hoạt động trong nhiều ngữ cảnh nhưng nó có nghĩa là dấu nháy đơn trong các từ rút gọn và sở hữu tạo thành ranh giới từ, có thể không phải là kết quả mong muốn
>>> 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'] 167116804
A workaround for apostrophes can be constructed using regular expressions
>>> 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'] 167116805
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
bytes. upper[]bytearray. upper[]Return a copy of the sequence with all the lowercase ASCII characters converted to their corresponding uppercase counterpart
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'] 167116806
Lowercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False53. Uppercase ASCII characters are those byte values in the sequence
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False54
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
bytes. zfill[width]bytearray. zfill[width]Return a copy of the sequence left filled with ASCII
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False76 digits to make a sequence of length width. A leading sign prefix [
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False77/
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False78] is handled by inserting the padding after the sign character rather than before. For objects, the original sequence is returned if width is less than or equal to
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False80
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'] 167116807
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
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 Bytes Formatting
Note
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]. If the value being printed may be a tuple or dictionary, wrap it in a tuple
Bytes objects [
>>> [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] 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'] 1671168083 operator [modulo]. This is also known as the bytes formatting or interpolation operator. 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'] 1671168084 [where format is a bytes object],
>>> 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'] 1671168083 conversion specifications in format are replaced with zero or more elements of values. 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'] 1671168086 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 bytes object, or a single mapping object [for example, a dictionary]
Trình xác định chuyển đổi chứa hai hoặc nhiều ký tự và có các thành phần sau, phải xảy ra theo thứ tự này
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, đánh dấu sự bắt đầu của trình xác địnhMapping 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]Cờ chuyển đổi [tùy chọn], ảnh hưởng đến kết quả của một số loại chuyển đổi
Độ rộng trường tối thiểu [tùy chọn]. Nếu được chỉ định là
>>> 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 [dấu hoa thị], chiều rộng thực tế được đọc từ phần tử tiếp theo của bộ giá trị và đối tượng cần chuyển đổi xuất hiện sau chiều rộng trường tối thiểu và độ chính xác tùy chọnĐộ chính xác [tùy chọn], được cho dưới 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
90 [dấu chấm] theo sau là độ chính xác. Nếu được chỉ định là>>> 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 [dấu hoa thị], thì độ chính xác thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu theo giá trị và giá trị cần chuyển đổi xuất hiện sau độ chính xácCông cụ sửa đổi độ dài [tùy chọn]
loại chuyển đổi
When the right argument is a dictionary [or other mapping type], then the formats in the bytes object 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'] 1671168087 character. The mapping key selects the value to be formatted from the mapping. 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'] 167116808
Trong trường hợp này, không có bộ chỉ định
>>> [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 nào có thể xuất hiện ở định dạng [vì chúng yêu cầu danh sách tham số tuần tự]
Các ký tự cờ chuyển đổi là
Lá cờ
Nghĩ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'] 1671168094
Việc chuyển đổi giá trị sẽ sử dụng “hình thức thay thế” [được định nghĩa bên dướ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'] 1671168077
Chuyển đổi sẽ được đệm bằng 0 cho các giá trị số
>>> 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'] 1671168079
Giá trị chuyển đổi được điều chỉnh trái [ghi đè chuyển đổ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'] 1671168077 nếu cả hai đều được cung cấp]
>>> 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'] 1671168098
[khoảng trắng] Nên để trống trước số dương [hoặc chuỗi trống] được tạo bởi chuyển đổi đã ký
>>> 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'] 1671168078
Một ký tự dấ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'] 1671168078 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'] 1671168079] sẽ đứng trước chuyển đổi [ghi đè cờ “dấu cách”]
Công cụ sửa đổi độ dà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 > [3.2].is_integer[] False5
New in version 3. 3
nbytesdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6084. This is the amount of space in bytes that the array would use in a contiguous representation. It is not necessarily equal 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'] --> 6085
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False6
mảng nhiều chiều
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False7
New in version 3. 3
readonlyA bool indicating whether the memory is read only
formatA string containing the format [in module style] for each element in the view. A memoryview can be created from exporters with arbitrary format strings, but some methods [e. g. ] are restricted to native single element formats
Changed in version 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'] --> 6088 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'] --> 6089. itemsize
The size in bytes of each element of the memoryview
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False8đim
An integer indicating how many dimensions of a multi-dimensional array the memory represents
shapeA tuple of integers the length of giving the shape of the memory as an N-dimensional array
Changed in version 3. 3. An empty tuple instead 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'] --> 631 when ndim = 0. strides
A tuple of integers the length of giving the size in bytes to access each element for each dimension of the array
Changed in version 3. 3. An empty tuple instead 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'] --> 631 when ndim = 0. suboffsets
Used internally for PIL-style arrays. The value is informational only
c_contiguousA bool indicating whether the memory is C-
New in version 3. 3
f_contiguousA bool indicating whether the memory is Fortran
New in version 3. 3
contiguousA bool indicating whether the memory is
New in version 3. 3
Set Types — ,
A set object is an unordered collection of distinct objects. Common uses include membership testing, removing duplicates from a sequence, and computing mathematical operations such as intersection, union, difference, and symmetric difference. [For other containers see the built-in , , and classes, and the module. ]
Like other collections, sets support
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6100,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6101, 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'] --> 6102. Being an unordered collection, sets do not record element position or order of insertion. Accordingly, sets do not support indexing, slicing, or other sequence-like behavior
There are currently two built-in set types, and . The type is mutable — the contents can be changed using methods 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'] --> 6106 and
>>> [65].to_bytes[] b'A'01. Since it is mutable, it has no hash value and cannot be used as either a dictionary key or as an element of another set. The type is immutable and — its contents cannot be altered after it is created; it can therefore be used as a dictionary key or as an element of another set
Non-empty sets [not frozensets] can be created by placing a comma-separated list of elements within braces, 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'] --> 6109, in addition to the constructor
The constructors for both classes work the same
class set[[iterable]]class frozenset[[iterable]]Return a new set or frozenset object whose elements are taken from iterable. The elements of a set must be . To represent sets of sets, the inner sets must be objects. If iterable is not specified, a new empty set is returned
Sets can be created by several means
Use a comma-separated list of elements within 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
109Use a set comprehension.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
113Use the type constructor.
def bit_length[self]: 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
Instances of and provide the following operations
len[s]Return the number of elements in set s [cardinality of s]
x in sTest x for membership in s
x not in sTest x for non-membership in s
isdisjoint[other]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'] --> 656 if the set has no elements in common with other. Sets are disjoint if and only if their intersection is the empty setissubset[other]set 6 120issuperset[other]set >= other
Test whether every element in other is in the set
set > otherTest whether the set is a proper superset of other, that 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'] --> 6121union[*others]set . other . .
Return a new set with elements from the set and all others
intersection[*others]set & other & .Return a new set with elements common to the set and all others
sự khác biệt[*khác]set - other - ...Return a new set with elements in the set that are not in the others
symmetric_difference[other]set ^ otherReturn a new set with elements in either the set or other but not both
copy[]Trả lại một bản sao nông của tập hợp
Note, the non-operator versions of , , , , , and methods will accept any iterable as an argument. In contrast, their operator based counterparts require their arguments to be sets. This precludes error-prone constructions 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'] --> 6128 in favor of the more readable
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6129
Both and support set to set comparisons. Two sets are equal if and only if every element of each set is contained in the other [each is a subset of the other]. A set is less than another set if and only if the first set is a proper subset of the second set [is a subset, but is not equal]. 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. 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'] --> 6134 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'] --> 656 and so does
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6136
The subset and equality comparisons do not generalize to a total ordering function. For example, any two nonempty disjoint sets are not equal and are not subsets of each other, so all of the following 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'] --> 638.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6138,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6139, 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'] --> 6140
Since sets only define partial ordering [subset relationships], the output of the method is undefined for lists of sets
Set elements, like dictionary keys, must be
Binary operations that mix instances with return the type of the first operand. 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'] --> 6144 returns an instance of
The following table lists operations available for that do not apply to immutable instances of
update[*others]set . = other . .Update the set, adding elements from all others
intersection_update[*others]set &= other & .Update the set, keeping only elements found in it and all others
difference_update[*others]set -= other . .Update the set, removing elements found in others
symmetric_difference_update[other]set ^= otherUpdate the set, keeping only elements found in either set, but not in both
add[elem]Add element elem to the set
remove[elem]Remove element elem from the set. Raises if elem is not contained in the set
discard[elem]Remove element elem from the set if it is present
pop[]Remove and return an arbitrary element from the set. Raises if the set is empty
clear[]Remove all elements from the set
Note, the non-operator versions of the , , , and methods will accept any iterable as an argument
Note, the elem argument to the
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 300, , and methods may be a set. To support searching for an equivalent frozenset, a temporary one is created from elem
Mapping Types —
Một đối tượng ánh xạ các giá trị tới các đối tượng tùy ý. Mappings are mutable objects. There is currently only one standard mapping type, the dictionary. [For other containers see the built-in , , and classes, and the module. ]
A dictionary’s keys are almost arbitrary values. Values that are not , that is, values containing lists, dictionaries or other mutable types [that are compared by value rather than by object identity] may not be used as keys. Values that compare equal [such 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'] --> 655,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6163, 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'] --> 656] can be used interchangeably to index the same dictionary entryclass dict[**kwargs]class dict[mapping , **kwargs]class dict[iterable , **kwargs]
Return a new dictionary initialized from an optional positional argument and a possibly empty set of keyword arguments
Dictionaries can be created by several means
Use a comma-separated list 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
165 pairs within 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
166 ordef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
167Use a dict comprehension.
def bit_length[self]: 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
169Use the type constructor.
def bit_length[self]: 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
If no positional argument is given, an empty dictionary is created. If a positional argument is given and it is a mapping object, a dictionary is created with the same key-value pairs as the mapping object. Otherwise, the positional argument must be an object. Each item in the iterable must itself be an iterable with exactly two objects. The first object of each item becomes a key in the new dictionary, and the second object the corresponding value. If a key occurs more than once, the last value for that key becomes the corresponding value in the new dictionary
If keyword arguments are given, the keyword arguments and their values are added to the dictionary created from the positional argument. If a key being added is already present, the value from the keyword argument replaces the value from the positional argument
To illustrate, the following examples all return a dictionary equal 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'] --> 6173
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False9
Providing keyword arguments as in the first example only works for keys that are valid Python identifiers. Otherwise, any valid keys can be used
These are the operations that dictionaries support [and therefore, custom mapping types should support too]
list[d]Return a list of all the keys used in the dictionary d
len[d]Return the number of items in the dictionary d
d[key]Return the item of d with key key. Raises a if key is not in the map
If a subclass of dict defines a method
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6175 and key is not present, 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'] --> 6176 operation calls that method with the key key as argument. 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'] --> 6176 operation then returns or raises whatever is returned or raised by 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'] --> 6178 call. No other operations or methods invoke
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6175. 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'] --> 6175 is not defined, is raised.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6175 must be a method; it cannot be an instance variable
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 600
The example above shows part of the implementation of . A different
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6184 method is used by d[key] = value
Set
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6176 to valuedel d[key]
Remove
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6176 from d. Raises a if key is not in the mapkey in d
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'] --> 656 if d has a key key, 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'] --> 638key not in d
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'] --> 6191iter[d]
Return an iterator over the keys of the dictionary. This is a shortcut for
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6192clear[]
Remove all items from the dictionary
copy[]Return a shallow copy of the dictionary
classmethod fromkeys[iterable[ , value]]Create a new dictionary with keys from iterable and values set to value
is a class method that returns a new dictionary. 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'] --> 631. All of the values refer to just a single instance, so it generally doesn’t make sense for value to be a mutable object such as an empty list. To get distinct values, use a insteadlấy[khóa[ , default]]
Return the value for key if key is in the dictionary, else default. If default is not given, 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'] --> 631, so that this method never raises a items[]
Return a new view of the dictionary’s items [
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6197 pairs]. xemkeys[]
Trả lại chế độ xem mới cho các khóa của từ điển. xem
bật[phím[ , default]]If key is in the dictionary, remove it and return its value, else return default. 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
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'] --> 6197 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 ý.
reversed[d]Return a reverse iterator over the keys of the dictionary. This is a shortcut for
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6204
Mới trong phiên bản 3. 8
setdefault[key[ , default]]If key is in the dictionary, return its value. If not, insert key with a value of default and return default. 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'] --> 631update[[other]]
Update the dictionary with the key/value pairs from other, overwriting existing keys. 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'] --> 631
accepts either another dictionary object or an iterable of key/value pairs [as tuples or other iterables of length two]. If keyword arguments are specified, the dictionary is then updated with those key/value pairs.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6208values[]
Return a new view of the dictionary’s values. See the
An equality comparison between one
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6209 view and another will always 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'] --> 638. This also applies when comparing
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6209 to itself
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 601d . other
Create a new dictionary with the merged keys and values of d and other, which must both be dictionaries. The values of other take priority when d and other share keys
New in version 3. 9
d . = otherUpdate the dictionary d with keys and values from other, which may be either a or an of key/value pairs. The values of other take priority when d and other share keys
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'] --> 6197 pairs [regardless of ordering]. Order comparisons [‘’] raise .
Dictionaries preserve insertion order. Note that updating a key does not affect the order. Keys added after deletion are inserted at the end
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 602
Changed in version 3. 7. Dictionary order is guaranteed to be insertion order. This behavior was an implementation detail of CPython from 3. 6.
Dictionaries and dictionary views are reversible
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 603
Changed in version 3. 8. Dictionaries are now reversible.
See also
can be used to create a read-only view of a
Dictionary view objects
The objects returned by , and are view objects. 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
Dictionary views can be iterated over to yield their respective data, and support membership tests
len[dictview]Return the number of entries in the dictionary
iter[dictview]Return an iterator over the keys, values or items [represented as tuples 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'] --> 6197] in the dictionary
Keys and values are iterated over in insertion order. This allows the creation 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'] --> 6220 pairs 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'] --> 6222. Another way to create the same list 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'] --> 6223
Iterating views while adding or deleting entries in the dictionary may raise a or fail to iterate over all entries
Changed in version 3. 7. Dictionary order is guaranteed to be insertion order.
x in dictviewReturn
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 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'] --> 6197 tuple]reversed[dictview]
Return a reverse iterator over the keys, values or items of the dictionary. The view will be iterated in reverse order of the insertion
Changed in version 3. 8. Dictionary views are now reversible.
dictview. mappingReturn a that wraps the original dictionary to which the view refers
Mới trong phiên bản 3. 10
Keys views are set-like since their entries are unique and hashable. If all values are hashable, so 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'] --> 6197 pairs are unique and hashable, then the items view is also set-like. [Values views are not treated as set-like since the entries are generally not unique. ] For set-like views, all of the operations defined for the abstract base class are available [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'] --> 678,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 674, 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'] --> 6232]
An example of dictionary view usage
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 604
Context Manager Types
Python’s statement supports the concept of a runtime context defined by a context manager. This is implemented using a pair of methods that allow user-defined classes to define a runtime context that is entered before the statement body is executed and exited when the statement ends
contextmanager. __enter__[]Enter the runtime context and return either this object or another object related to the runtime context. The value returned by this method is bound to the identifier in 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'] --> 6234 clause of statements using this context manager
An example of a context manager that returns itself is a . File objects return themselves from __enter__[] to allow to be used as the context expression in a statement
An example of a context manager that returns a related object is the one returned by . 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. This allows changes to be made to the current decimal context in the body of the statement without affecting code outside 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'] --> 6081 statementtrình quản lý ngữ cảnh. __exit__[exc_type , exc_val , exc_tb]
Exit the runtime context and return a Boolean flag indicating if any exception that occurred should be suppressed. If an exception occurred while executing the body of the statement, the arguments contain the exception type, value and traceback information. Otherwise, all three arguments are
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631
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'] --> 6081. Otherwise the exception continues propagating after this method has finished executing. 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'] --> 6081
The exception passed in should never be reraised explicitly - instead, this method should return a false value to indicate that the method completed successfully and does not want to suppress the raised exception. Đ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. The specific types are not treated specially beyond their implementation of the context management protocol. See the module for some examples
Python’s s and the decorator provide a convenient way to implement these protocols. 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í
Note that there is no specific slot for any of these methods in the type structure for Python objects in the Python/C API. Extension types wanting to define these methods must provide them as a normal Python accessible method. Compared to the overhead of setting up the runtime context, the overhead of a single class dictionary lookup is negligible
Type Annotation Types — ,
The core built-in types for are and
Generic Alias Type
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 objects are generally created by a class. They are most often used with , such as or . 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'] --> 6255 is 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'] --> 6252 object created by subscripting the
def bit_count[self]: return bin[self].count["1"]93 class with the argument .
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 objects are intended primarily for use with
Note
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'] --> 6252 hoạt động như một proxy cho một , triển khai các generic được tham số hóa
For a container class, the argument[s] supplied to a of the class may indicate the type[s] of the elements an object contains. 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'] --> 6262 can be used in type annotations to signify a in which all the elements are of type
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ủadef bit_length[self]: 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ớidef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
252def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
275Nế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 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ằngdef bit_length[self]: 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'] --> 6252 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'] --> 6252T[X, Y, . ]
Creates 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'] --> 6252 representing a type
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6289 parameterized by types X, Y, and more depending on 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'] --> 6289 used. 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'] --> 605
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ị. In this example, the function expects a
>>> [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 with keys of type and values of type
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 606
The builtin functions and do not accept
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 types for their second argument
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 607
The Python runtime does not enforce . This extends to generic types and their type parameters. 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'] --> 6252, the elements in the container are not checked against their type. For example, the following code is discouraged, but will run without errors
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 608
Furthermore, parameterized generics erase type parameters during object creation
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 609
Calling or on a generic shows the parameterized type
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 610
The method of generic containers will raise an exception to disallow mistakes 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'] --> 6304
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 611
However, such expressions are valid when are used. The index must have as many elements as there are type variable items in 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'] --> 6252 object’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'] --> 612
Standard Generic Classes
The following standard library classes support parameterized generics. This list is non-exhaustive
Special Attributes 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
252 objects
All parameterized generics implement special read-only attributes
genericalias. __origin__This attribute points at the non-parameterized generic class
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 613genericalias. __args__
This attribute is a [possibly of length 1] of generic types passed to the original of the generic class
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 614genericalias. __parameters__
This attribute is a lazily computed tuple [possibly empty] of unique type variables found in
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6306
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 615
Note
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'] --> 6252 object with parameters may not have correct
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6365 after substitution because is intended primarily for static type checkinggenericalias. __unpacked__
A boolean that is true if the alias has been unpacked using 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'00 operator [see ]
New in version 3. 11
See also
PEP 484 - Type HintsIntroducing Python’s framework for type annotations
PEP 585 - Type Hinting Generics In Standard CollectionsIntroducing the ability to natively parameterize standard-library classes, provided they implement the special class method
, andDocumentation on how to implement generic classes that can be parameterized at runtime and understood by static type-checkers
New in version 3. 9
Union Type
A union object holds the value of 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'] --> 6371 [bitwise or] operation on multiple . These types are intended primarily for . The union type expression enables cleaner type hinting syntax compared to X . Y . .
Defines a union object which holds types X, Y, and so forth.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6373 means either X or Y. It 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'] --> 6374. For example, the following function expects an argument of type 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'] --> 616union_object == other
Union objects can be tested for equality with other union objects. Details
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
17Redundant types are removed
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
18When comparing unions, the order is ignored
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
19Nó 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
20Cá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
31def bit_length[self]: 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
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'] --> 622
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'] --> 623
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'] --> 624
Note
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'] --> 6383 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'] --> 6373. Nếu một siêu dữ liệu triển khai
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6383, Liên minh có thể ghi đè lên 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'] --> 625
See also
PEP 604 – PEP proposing 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'] --> 6373 syntax and the Union type
Mới trong phiên bản 3. 10
Other Built-in Types
Trình thông dịch hỗ trợ một số loại đối tượng khác. Most of these support only one or two operations
Modules
The only special operation on a module is attribute access.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6387, where m is a module and name accesses a name defined in m’s symbol table. Module attributes can be assigned to. [Note that the statement is not, strictly speaking, an operation on a module 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'] --> 6389 does not require a module object named foo to exist, rather it requires an [external] definition for a module named foo somewhere. ]
A special attribute of every module is . This is the dictionary containing the module’s symbol table. Modifying this dictionary will actually change the module’s symbol table, but direct assignment to the attribute is not possible [you can write
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6392, which defines
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6393 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'] --> 655, but you can’t write
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6395]. Modifying directly is not recommended
Modules built into the interpreter are written like this.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6397. If loaded from a file, they are written 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'] --> 6398
Classes and Class Instances
See and for these
Functions
Function objects are created by function definitions. The only operation on a function object is to call 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'] --> 6399
There are really two flavors of function objects. built-in functions and user-defined functions. Both support the same operation [to call the function], but the implementation is different, hence the different object types
See for more information
Methods
Methods are functions that are called using the attribute notation. There are two flavors. built-in methods [such 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'] --> 6400 on lists] and class instance methods. Built-in methods are described with the types that support them
If you access a method [a function defined in a class namespace] through an instance, you get a special object. a bound method [also called instance method] object. When called, it will add 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'] --> 6401 argument to the argument list. Bound methods have two special read-only attributes.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6402 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'] --> 6403 is the function implementing the method. Calling
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6404 is completely equivalent to calling
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6405
Like function objects, bound method objects support getting arbitrary attributes. However, since method attributes are actually stored 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'] --> 6406], setting method attributes on bound methods is disallowed. Attempting to set an attribute on a method results in an being raised. 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'] --> 626
See for more information
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'] --> 6409 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'] --> 6409 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'] --> 6412 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'] --> 6413 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'] --> 6414
A code object can be executed or evaluated by passing it [instead of a source string] to the or built-in functions
See for more information
Type Objects
Type objects represent the various object types. An object’s type is accessed by the built-in function . There are no special operations on types. The standard module defines names for all standard built-in types
Types are written like this.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6419
The Null Object
This object is returned by functions that don’t explicitly return a value. It supports no special operations. 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'] --> 631 [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'] --> 6421 produces the same 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'] --> 631
Đối tượng Dấu chấm lửng
This object is commonly used by slicing [see ]. It supports no special operations. There is exactly one ellipsis object, named [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'] --> 6424 produces the singleton
It is written 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'] --> 6423 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'] --> 6427
The NotImplemented Object
This object is returned from comparisons and binary operations when they are asked to operate on types they don’t support. See for more information. There is exactly one
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6428 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'] --> 6429 produces the singleton instance
It is written 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'] --> 6428
Boolean Values
Boolean values are the two constant objects
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 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'] --> 656. They are used to represent truth values [although other values can also be considered false or true]. In numeric contexts [for example when used as the argument to an arithmetic operator], they behave like the integers 0 and 1, respectively. 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]
They are written 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'] --> 638 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'] --> 656, respectively
Internal Objects
See for this information. It describes stack frame objects, traceback objects, and slice objects
Special Attributes
The implementation adds a few special read-only attributes to several object types, where they are relevant. Some of these are not reported by the built-in function
object. __dict__A dictionary or other mapping object used to store an object’s [writable] attributes
instance. __class__The class to which a class instance belongs
class. __bases__The tuple of base classes of a class object
definition. __name__The name of the class, function, method, descriptor, or generator instance
definition. __qualname__The of the class, function, method, descriptor, or generator instance
New in version 3. 3
lớp. __mro__This attribute is a tuple of classes that are considered when looking for base classes during method resolution
class. mro[]This method can be overridden by a metaclass to customize the method resolution order for its instances. It is called at class instantiation, and its result is stored in
class. __subclasses__[]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ả các tham chiếu vẫn còn tồn tại. The list is in definition order. 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'] --> 627
Integer string conversion length limitation
CPython has a global limit for converting between and to mitigate denial of service attacks. This limit only applies to decimal or other non-power-of-two number bases. Hexadecimal, octal, and binary conversions are unlimited. The limit can be configured
The type in CPython is an arbitrary length number stored in binary form [commonly known as a “bignum”]. There exists no algorithm that can convert a string to a binary integer or a binary integer to a string in linear time, unless the base is a power of 2. Even the best known algorithms for base 10 have sub-quadratic complexity. Converting a large value such 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'] --> 6441 can take over a second on a fast CPU
Limiting conversion size offers a practical way to avoid CVE-2020-10735
The limit is applied to the number of digit characters in the input or output string when a non-linear conversion algorithm would be involved. Underscores and the sign are not counted towards the limit
When an operation would exceed the limit, a is raised
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 628
The default limit is 4300 digits as provided in . The lowest limit that can be configured is 640 digits as provided in
Verification
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 629
New in version 3. 11
Affected APIs
The limitation only applies to potentially slow conversions between and 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
448 with default base 10def bit_length[self]: 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 2def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
450def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
451any other string conversion to base 10, 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
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, ordef bit_length[self]: 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
The limitations do not apply to functions with a linear algorithm
def bit_length[self]: 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 with base 2, 4, 8, 16, or 32and
, ,
for hex, octal, and binary numbers
to
to
Configuring the limit
Before Python starts up you can use an environment variable or an interpreter command line flag to configure the limit
, 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 to set the limit to 640 ordef bit_length[self]: 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 to disable the limitation, 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
469def bit_length[self]: 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 contains the value of or . Nếu cả env var và tùy chọndef bit_length[self]: 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 đều được đặt, thì tùy chọndef bit_length[self]: 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. A value of -1 indicates that both were unset, thus a value ofdef bit_length[self]: 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 was used during initialization
From code, you can inspect the current limit and set a new one using these APIs
and are a getter and setter for the interpreter-wide limit. Subinterpreters have their own limit
Information about the default and minimum can be found in
is the compiled-in default limit
is the lowest accepted value for the limit [other than 0 which disables it]
New in version 3. 11
Caution
Setting a low limit can lead to problems. While rare, code exists that contains integer constants in decimal in their source that exceed the minimum threshold. A consequence of setting the limit is that Python source code containing decimal integer literals longer than the limit will encounter an error during parsing, usually at startup time or import time or even at installation time - anytime an up to date
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6482 does not already exist for the code. A workaround for source that contains such large constants is to convert them to
def bit_count[self]: return bin[self].count["1"]12 hexadecimal form as it has no limit
Test your application thoroughly if you use a low limit. Ensure your tests run with the limit set early via the environment or flag so that it applies during startup and even during any installation step that may invoke Python to precompile
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6484 sources 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'] --> 6482 files
Recommended configuration
The default
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6443 is expected to be reasonable for most applications. If your application requires a different limit, set it from your main entry point using Python version agnostic code as these APIs were added in security patch releases in versions before 3. 11
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'] --> 630
If you need to disable it entirely, set it 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'] --> 642
Footnotes
Additional information on these special methods may be found in the Python Reference Manual []
As a consequence, the 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'] --> 6488 is considered equal 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'] --> 6489, and similarly for tuples
They must have since the parser can’t tell the type of the operands
4[,,,]Cased characters are those with general category property being one of “Lu” [Letter, uppercase], “Ll” [Letter, lowercase], or “Lt” [Letter, titlecase]
5[,]To format only a tuple you should therefore provide a singleton tuple whose only element is the tuple to be formatted