Một số lớp bộ sưu tập có thể thay đổi. Các phương thức cộng, trừ hoặc sắp xếp lại các thành viên của chúng tại chỗ và không trả về một mục cụ thể, không bao giờ trả về chính thể hiện của bộ sưu tập nhưng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631
Một số hoạt động được hỗ trợ bởi một số loại đối tượng; . Hàm thứ hai được sử dụng ngầm khi một đối tượng được viết bởi hàm
Kiểm tra giá trị thật
Bất kỳ đối tượng nào cũng có thể được kiểm tra giá trị thực, để sử dụng trong một hoặc điều kiện hoặc dưới dạng toán hạng của các phép toán Boolean bên dưới
Theo mặc định, một đối tượng được coi là đúng trừ khi lớp của nó định nghĩa một phương thức
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 637 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 hoặc một phương thức
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 639 trả về 0 khi được gọi với đối tượng. Dưới đây là hầu hết các đối tượng tích hợp được coi là sai
hằng số được xác định là sai.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
31 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
38số không của bất kỳ loại số nào.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
42,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
43,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
44,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
45,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
46trình tự và bộ sưu tập trống.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
47,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
48,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
49,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
50,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
51,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
52
Các phép toán và hàm dựng sẵn có kết quả Boolean luôn trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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ận
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 đố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
The behavior of the and operators cannot be customized; also they can be applied to any two objects and never raise an exception
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 phẩy độ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 = 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ùng.
>>> 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 phép tính này với ít nhất một bit mở rộng dấu phụ trong biểu diễn phần bù của hai hữu hạn [độ rộng bit làm việc là
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
80 trở lên] là đủ để có được kết quả tương tự như thể có vô số bit dấu
Các phương thức bổ sung trên các kiểu số nguyên
Kiểu int thực hiện. Ngoài ra nó còn cung cấp thêm một số phương pháp
int. bit_length[]Trả về số bit cần thiết để biểu diễn một số nguyên ở dạng nhị phân, không bao gồm dấu và các số 0 ở đầu
>>> n = -37 >>> bin[n] '-0b100101' >>> n.bit_length[] 6
Chính xác hơn, nếu
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 382 khác 0, 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ố. Thí 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 if the float instance is finite with integral value, and
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False
Two methods support conversion to and from hexadecimal strings. Since Python’s floats are stored internally as binary numbers, converting a float to or from a decimal string usually involves a small rounding error. In contrast, hexadecimal strings allow exact representation and specification of floating-point numbers. This can be useful when debugging, and in numerical work
float. hex[]Return a representation of a floating-point number as a hexadecimal string. For finite floating-point numbers, this representation will always include a leading
def bit_count[self]: return bin[self].count["1"]12 and a trailing
def bit_count[self]: return bin[self].count["1"]13 and exponentclassmethod float. fromhex[s]
Class method to return the float represented by a hexadecimal string s. The string s may have leading and trailing whitespace
Note that is an instance method, while is a class method
A hexadecimal string takes the form
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 60
where the optional
def bit_count[self]: return bin[self].count["1"]16 may by either
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 369 or
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 370,
def bit_count[self]: return bin[self].count["1"]19 and
def bit_count[self]: return bin[self].count["1"]20 are strings of hexadecimal digits, and
def bit_count[self]: return bin[self].count["1"]21 is a decimal integer with an optional leading sign. Case is not significant, and there must be at least one hexadecimal digit in either the integer or the fraction. This syntax is similar to the syntax specified in section 6. 4. 4. 2 of the C99 standard, and also to the syntax used in Java 1. 5 onwards. In particular, the output of is usable as a hexadecimal floating-point literal in C or Java code, and hexadecimal strings produced by C’s
def bit_count[self]: return bin[self].count["1"]23 format character or Java’s
def bit_count[self]: return bin[self].count["1"]24 are accepted by
Note that the exponent is written in decimal rather than hexadecimal, and that it gives the power of 2 by which to multiply the coefficient. For example, the hexadecimal string
def bit_count[self]: return bin[self].count["1"]26 represents the floating-point number
def bit_count[self]: return bin[self].count["1"]27, or
def bit_count[self]: return bin[self].count["1"]28
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61
Applying the reverse conversion to
def bit_count[self]: return bin[self].count["1"]28 gives a different hexadecimal string representing the same number
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62
Hashing of numeric types
For numbers
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 382 and
def bit_count[self]: return bin[self].count["1"]31, possibly of different types, it’s a requirement that
def bit_count[self]: return bin[self].count["1"]32 whenever
def bit_count[self]: return bin[self].count["1"]33 [see the method documentation for more details]. For ease of implementation and efficiency across a variety of numeric types [including , , and ] Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of and , and all finite instances of and . Essentially, this function is given by reduction modulo
def bit_count[self]: return bin[self].count["1"]43 for a fixed prime
def bit_count[self]: return bin[self].count["1"]43. The value of
def bit_count[self]: return bin[self].count["1"]43 is made available to Python as the
def bit_count[self]: return bin[self].count["1"]46 attribute of
CPython implementation detail. Currently, the prime used is
def bit_count[self]: return bin[self].count["1"]48 on machines with 32-bit C longs and
def bit_count[self]: return bin[self].count["1"]49 on machines with 64-bit C longs
Here are the rules in detail
If
def bit_count[self]: return bin[self].count["1"]
50 is a nonnegative rational number anddef bit_count[self]: return bin[self].count["1"]
51 is not divisible bydef bit_count[self]: return bin[self].count["1"]
43, definedef bit_count[self]: return bin[self].count["1"]
53 asdef bit_count[self]: return bin[self].count["1"]
54, wheredef bit_count[self]: return bin[self].count["1"]
55 gives the inverse ofdef bit_count[self]: return bin[self].count["1"]
51 modulodef bit_count[self]: return bin[self].count["1"]
43If
def bit_count[self]: return bin[self].count["1"]
50 is a nonnegative rational number anddef bit_count[self]: return bin[self].count["1"]
51 is divisible bydef bit_count[self]: return bin[self].count["1"]
43 [butdef bit_count[self]: return bin[self].count["1"]
61 is not] thendef bit_count[self]: return bin[self].count["1"]
51 has no inverse modulodef bit_count[self]: return bin[self].count["1"]
43 and the rule above doesn’t apply; in this case definedef bit_count[self]: return bin[self].count["1"]
53 to be the constant valuedef bit_count[self]: return bin[self].count["1"]
65Nế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. If the resulting hash is>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
41, replace it withdef bit_count[self]: return bin[self].count["1"]
70The particular values
def bit_count[self]: return bin[self].count["1"]
65 anddef bit_count[self]: return bin[self].count["1"]
72 are used as hash values for positive infinity or negative infinity [respectively]For a number
def bit_count[self]: return bin[self].count["1"]
74, the hash values of the real and imaginary parts are combined by computingdef bit_count[self]: return bin[self].count["1"]
75, reduced modulodef bit_count[self]: return bin[self].count["1"]
76 so that it lies indef bit_count[self]: return bin[self].count["1"]
77. Again, if the result is>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
41, it’s replaced withdef bit_count[self]: return bin[self].count["1"]
70
To clarify the above rules, here’s some example Python code, equivalent to the built-in hash, for computing the hash of a rational number, , or
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63
Iterator Types
Python supports a concept of iteration over containers. This is implemented using two distinct methods; these are used to allow user-defined classes to support iteration. Sequences, described below in more detail, always support the iteration methods
One method needs to be defined for container objects to provide support
container. __iter__[]Return an object. The object is required to support the iterator protocol described below. If a container supports different types of iteration, additional methods can be provided to specifically request iterators for those iteration types. [An example of an object supporting multiple forms of iteration would be a tree structure which supports both breadth-first and depth-first traversal. ] This method corresponds to the slot of the type structure for Python objects in the Python/C API
The iterator objects themselves are required to support the following two methods, which together form the iterator protocol
iterator. __iter__[]Return the object itself. This is required to allow both containers and iterators to be used with the and statements. This method corresponds to the slot of the type structure for Python objects in the Python/C API
iterator. __next__[]Return the next item from the . If there are no further items, raise the exception. This method corresponds to the slot of the type structure for Python objects in the Python/C API
Python defines several iterator objects to support iteration over general and specific sequence types, dictionaries, and other more specialized forms. The specific types are not important beyond their implementation of the iterator protocol
Once an iterator’s method raises , it must continue to do so on subsequent calls. Implementations that do not obey this property are deemed broken
Generator Types
Python’s s provide a convenient way to implement the iterator protocol. If a container object’s
def bit_count[self]: return bin[self].count["1"]90 method is implemented as a generator, it will automatically return an iterator object [technically, a generator object] supplying the
def bit_count[self]: return bin[self].count["1"]90 and methods. More information about generators can be found in
Sequence Types — , ,
There are three basic sequence types. lists, tuples, and range objects. Additional sequence types tailored for processing of and are described in dedicated sections
Common Sequence Operations
The operations in the following table are supported by most sequence types, both mutable and immutable. The ABC is provided to make it easier to correctly implement these operations on custom sequence types
This table lists the sequence operations sorted in ascending priority. In the table, s and t are sequences of the same type, n, i, j and k are integers and x is an arbitrary object that meets any type and value restrictions imposed by s
The
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 698 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'] --> 699 operations have the same priorities as the comparison operations. The
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 369 [concatenation] and
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'00 [repetition] operations have the same priority as the corresponding numeric operations.
Hoạt động
Kết quả
ghi chú
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'01
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 if an item of s is equal to x, else
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 if an item of s is equal to x, else
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
the concatenation of s and t
[6][7]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'08 or
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'09
equivalent to adding s to itself n times
[2][7]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'10
ith item of s, origin 0
[3]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'11
slice of s from i to j
[3][4]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'12
slice of s from i to j with step k
[3][5]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'13
length of s
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'14
smallest item of s
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'15
largest item of s
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'16
index of the first occurrence of x in s [at or after index i and before index j]
[8]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'17
total number of occurrences of x in s
Sequences of the same type also support comparisons. In particular, tuples and lists are compared lexicographically by comparing corresponding elements. This means that to compare equal, every element must compare equal and the two sequences must be of the same type and have the same length. [For full details see in the language reference. ]
Forward and reversed iterators over mutable sequences access values using an index. That index will continue to march forward [or backward] even if the underlying sequence is mutated. The iterator terminates only when an or a is encountered [or when the index drops below zero]
ghi chú
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
6Giải thích thêm có sẵn trong mục Câu hỏi thường gặp
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. Nhưng lưu ý rằ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'
32 vẫn 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
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. Khi k âm, i và j giảm xuống _______114_______48 nếu chúng lớn hơn. Nếu i hoặc j bị bỏ qua hoặcdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
31, chúng trở thành giá trị “kết thúc” [kết thúc này phụ thuộc vào dấu của 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. To get a linear runtime cost, you must switch to one of the alternatives below
if concatenating objects, you can build a list and use at the end or else write to an instance and retrieve its value when complete
if concatenating objects, you can similarly use or , or you can do in-place concatenation with a object. objects are mutable and have an efficient overallocation mechanism
if concatenating objects, extend a instead
for other types, investigate the relevant class documentation
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
the elements of
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'12 are replaced by those of t
[1]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'81
removes the elements of
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'12 from the list
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'83
appends x to the end of the sequence [same as
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'84]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'85
removes all items from s [same as
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'86]
[5]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'87
creates a shallow copy of s [same as
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'88]
[5]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'89 or
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'90
extends s with the contents of t [for the most part the same as
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'91]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'92
updates s with its contents repeated n times
[6]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'93
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 or
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'96
retrieves the item at i and also removes it from s
[2]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'97
remove the first item from s where
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'10 is equal to x
[3]
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'99
reverses the items of s in place
[4]
ghi chú
t must have the same length as the slice it is replacing
The optional argument i defaults to
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 3
41, so that by default the last item is removed and returned>>> [65].to_bytes[] b'A'
01 raises when x is not found in sThe
>>> [65].to_bytes[] b'A'
03 method modifies the sequence in place for economy of space when reversing a large sequence. To remind users that it operates by side effect, it does not return the reversed sequence>>> [65].to_bytes[] b'A'
04 and>>> [65].to_bytes[] b'A'
05 are included for consistency with the interfaces of mutable containers that don’t support slicing operations [such as and ].>>> [65].to_bytes[] b'A'
05 is not part of the ABC, but most concrete mutable sequence classes provide itNew in version 3. 3.
>>> [65].to_bytes[] b'A'
04 and>>> [65].to_bytes[] b'A'
05 methods.The value n is an integer, or an object implementing . Zero and negative values of n clear the sequence. Items in the sequence are not copied; they are referenced multiple times, as explained for
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'
08 under
Lists
Lists are mutable sequences, typically used to store collections of homogeneous items [where the precise degree of similarity will vary by application]
class list[[iterable]]Lists may be constructed in several ways
Using a pair of square brackets to denote the empty list.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
49Using square brackets, separating items with commas.
>>> [65].to_bytes[] b'A'
15,>>> [65].to_bytes[] b'A'
16Using a list comprehension.
>>> [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'
43Using the built-in.
>>> [65].to_bytes[] b'A'
44 or>>> [65].to_bytes[] b'A'
46
The constructor builds a tuple whose items are the same and in the same order as iterable’s items. iterable may be either a sequence, a container that supports iteration, or an iterator object. If iterable is already a tuple, it is returned unchanged. For example,
>>> [65].to_bytes[] b'A'47 returns
>>> [65].to_bytes[] b'A'48 and
>>> [65].to_bytes[] b'A'49 returns
>>> [65].to_bytes[] b'A'50. Nếu không có đối số nào được đưa ra, hàm tạo sẽ tạo một bộ dữ liệu trống mớ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'] --> 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. Phạm vi hỗ trợ các chỉ số âm, nhưng chúng được hiểu là lập chỉ mục từ cuối chuỗi được xác định bởi các chỉ số dương
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]
bắt đầuThe 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. Strings are immutable of Unicode code points. 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
String literals that are part of a single expression and have only whitespace between them will be implicitly converted to a single string literal. That is,
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]00
See for more about the various forms of string literal, including supported escape sequences, and the
>>> [65].to_bytes[] b'A'62 [“raw”] prefix that disables most escape sequence processing
Strings may also be created from other objects using the constructor
Since there is no separate “character” type, indexing a string produces strings of length 1. That is, for a non-empty string s,
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]03
There is also no mutable string type, but or can be used to efficiently construct strings from multiple fragments
Changed in version 3. 3. For backwards compatibility with the Python 2 series, the
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]06 prefix is once again permitted on string literals. It has no effect on the meaning of string literals and cannot be combined with the
>>> [65].to_bytes[] b'A'62 prefix. class str[object='']class str[object=b'' , encoding='utf-8' , errors='strict']
Return a version of object. If object is not provided, returns the empty string. Otherwise, the behavior of
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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. Đối với các đối tượng chuỗi, đây chính là chuỗi. 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. Since it is already lowercase, would do nothing 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]28; converts it 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
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. ] Nếu ký tự là một dòng mớ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]47] hoặc trả về [
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], nó sẽ được sao chép và cột hiện tại được đặt lại về 0. 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
When formatting a number [, , , and subclasses] with the
def bit_count[self]: return bin[self].count["1"]51 type [ex.
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]59], the function temporarily sets the
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]60 locale to the
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]61 locale to decode
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]62 and
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]63 fields of
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]64 if they are non-ASCII or longer than 1 byte, and the
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]61 locale is different than the
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]60 locale. This temporary change affects other threads
Changed in version 3. 7. Khi định dạng một số với kiểu
def bit_count[self]: return bin[self].count["1"]51, hàm sẽ tạm thời đặt ngôn 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]60 thành ngôn 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]61 trong một số trường hợp. str. format_map[mapping]
Similar to
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]70, except that
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]71 is used directly and not copied to a . This is useful if for example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]71 is a dict subclass
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 33
Mới trong phiên bản 3. 2
str. index[sub[ , start[ , end]]]Like , but raise when the substring is not found
str. isalnum[]Return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 if all characters in the string are alphanumeric and there is at least one character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise. A character
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]78 is alphanumeric if one of the following returns
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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, or
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]83str. 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 characters in the string are alphabetic and there is at least one character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise. Alphabetic characters are those characters defined in the Unicode character database as “Letter”, i. e. , those with general category property being one of “Lm”, “Lt”, “Lu”, “Ll”, or “Lo”. Note that this is different from the “Alphabetic” property defined in the Unicode Standardstr. 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 string is empty or all characters in the string are ASCII,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise. ASCII characters have code points in the range U+0000-U+007F
New in version 3. 7
str. isdecimal[]Return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 if all characters in the string are decimal characters and there is at least one character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise. Decimal characters are those that can be used to form numbers in base 10, e. g. U+0660, ARABIC-INDIC DIGIT ZERO. Formally a decimal character is a character in the Unicode General Category “Nd”str. isdigit[]
Return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 if all characters in the string are digits and there is at least one character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise. Digits include decimal characters and digits that need special handling, such as the compatibility superscript digits. This covers digits which cannot be used to form numbers in base 10, like the Kharosthi numbers. Formally, a digit is a character that has the property value Numeric_Type=Digit or Numeric_Type=Decimalstr. isidentifier[]
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 is a valid identifier according to the language definition, section
Call to test whether string
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]94 is a reserved identifier, such as and
Example
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 34str. 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 all cased characters in the string are lowercase and there is at least one cased character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwisestr. isnumeric[]
Return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 if all characters in the string are numeric characters, and there is at least one character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise. 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, VULGAR FRACTION ONE FIFTH. Formally, numeric characters are those with the property value Numeric_Type=Digit, Numeric_Type=Decimal or Numeric_Type=Numericstr. isprintable[]
Return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 if all characters in the string are printable or the string is empty,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise. Nonprintable characters are those characters defined in the Unicode character database as “Other” or “Separator”, excepting the ASCII space [0x20] which is considered printable. [Note that printable characters in this context are those which should not be escaped when is invoked on a string. It has no bearing on the handling of strings written to or . ]str. isspace[]
Return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 if there are only whitespace characters in the string and there is at least one character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise
A character is whitespace if in the Unicode character database [see ], either its general category is
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168009 [“Separator, space”], or its bidirectional class is one of
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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, or
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168012str. 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 string is a titlecased string and there is at least one character, for example uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return
def bit_length[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 otherwisestr. 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 all cased characters in the string are uppercase and there is at least one cased character,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 otherwise
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 35str. join[iterable]
Return a string which is the concatenation of the strings in iterable. A will be raised if there are any non-string values in iterable, including objects. 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 , /]If the string starts with the prefix string, return
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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 , /]If the string ends with the suffix string and that suffix is not empty, return
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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. replace[old , new[ , count]]Return a copy of the string with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced
str. rfind[sub[ , start[ , end]]]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. 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 on failurestr. rindex[sub[ , start[ , end]]]
Like but raises when the substring sub is not found
str. rjust[width[ , fillchar]]Return the string right justified in a string of length width. Padding is done using the specified fillchar [default is an ASCII space]. The original string is returned if width is less than or equal to
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'13str. rpartition[sep]
Split the string at the last occurrence of sep, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing two empty strings, followed by the string itself
str. rsplit[sep=None , maxsplit=- 1]Return a list of the words in the string, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done, the rightmost ones. If sep is not specified or
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, any whitespace string is a separator. Except for splitting from the right, behaves like which is described in detail belowstr. rstrip[[chars]]
Return a copy of the string with trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
See for a method that will remove a single suffix string rather than all of a set of characters. For example
def bit_count[self]: return bin[self].count["1"]1str. split[sep=None , 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. If maxsplit is given, at most maxsplit splits are done [thus, the list will have at most
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168037 elements]. If maxsplit is not specified or
>>> 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 strings [for example,
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168039 returns
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168040]. The sep argument may consist of multiple characters [for example,
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168041 returns
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168042]. Splitting an empty string with a specified separator returns
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168043
For example
def bit_count[self]: return bin[self].count["1"]2
If sep is not specified or is
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, a different splitting algorithm is applied. runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace. Consequently, splitting an empty string or a string consisting of just whitespace with a
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631 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
For example
def bit_count[self]: return bin[self].count["1"]3str. splitlines[keepends=False]
Return a list of the lines in the string, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true
This method splits on the following line boundaries. In particular, the boundaries are a superset of
Representation
Description
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]47
Line Feed
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
Carriage Return
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168049
Carriage Return + Line Feed
>>> 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 or
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168051
Line Tabulation
>>> 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 or
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168053
Form Feed
>>> 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
File Separator
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168055
Group Separator
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168056
Record Separator
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168057
Next Line [C1 Control Code]
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168058
Line Separator
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168059
Dấu phân cách đoạn văn
Changed in version 3. 2.
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168050 and
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168052 added to list of line boundaries.
For example
def bit_count[self]: return bin[self].count["1"]4
Unlike when a delimiter string sep is given, this method returns an empty list for the empty string, and a terminal line break does not result in an extra line
def bit_count[self]: return bin[self].count["1"]5
For comparison,
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168063 gives
def bit_count[self]: return bin[self].count["1"]6str. 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 string starts with the prefix, otherwise return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. prefix can also be a tuple of prefixes to look for. With optional start, test string beginning at that position. With optional end, stop comparing string at that positionstr. strip[[chars]]
Return a copy of the string with the leading and trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, the chars argument defaults to removing whitespace. The chars argument is not a prefix or suffix; rather, all combinations of its values are stripped
def bit_count[self]: return bin[self].count["1"]7
The outermost leading and trailing chars argument values are stripped from the string. Characters are removed from the leading end until reaching a string character that is not contained in the set of characters in chars. A similar action takes place on the trailing end. For example
def bit_count[self]: return bin[self].count["1"]8str. swapcase[]
Return a copy of the string with uppercase characters converted to lowercase and vice versa. Note that it is not necessarily true that
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168067str. title[]
Return a titlecased version of the string where words start with an uppercase character and the remaining characters are lowercase
For example
def bit_count[self]: return bin[self].count["1"]9
The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries, which may not be the desired result
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'0
The function does not have this problem, as it splits words on spaces only
Alternatively, a workaround for apostrophes can be constructed using regular expressions
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'1str. translate[table]
Return a copy of the string in which each character has been mapped through the given translation table. The table must be an object that implements indexing via
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168069, typically a or . When indexed by a Unicode ordinal [an integer], the table object can do any of the following. return a Unicode ordinal or a string, to map the character to one or more other characters; return
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, to delete the character from the return string; or raise a exception, to map the character to itself
You can use to create a translation map from character-to-character mappings in different formats
See also the module for a more flexible approach to custom character mappings
str. upper[]Return a copy of the string with all the cased characters converted to uppercase. Note that
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168074 might be
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 if
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]94 contains uncased characters or if the Unicode category of the resulting character[s] is not “Lu” [Letter, uppercase], but e. g. “Lt” [Letter, titlecase]
The uppercasing algorithm used is described in section 3. 13 of the Unicode Standard
str. zfill[width]Return a copy of the string left filled with ASCII
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168077 digits to make a string of length width. A leading sign prefix [
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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] is handled by inserting the padding after the sign character rather than before. The original string is returned if width is less than or equal to
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'13
For example
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'2
def to_bytes[n, length=1, byteorder='big', signed=False]:
if byteorder == 'little':
order = range[length]
elif byteorder == 'big':
order = reversed[range[length]]
else:
raise ValueError["byteorder must be either 'little' or 'big'"]
return bytes[[n >> i*8] & 0xff for i in order]
26-style String Formatting
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]. Using the newer , the interface, or may help avoid these errors. Each of these alternatives provides their own trade-offs and benefits of simplicity, flexibility, and/or extensibility
String objects have one unique built-in operation. the
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168083 operator [modulo]. This is also known as the string 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 string],
>>> 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 string, or a single mapping object [for example, a dictionary]
A conversion specifier contains two or more characters and has the following components, which must occur in this order
The
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
87 character, which marks the start of the specifierMapping 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
Minimum field width [optional]. If specified as an
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
89 [asterisk], the actual width is read from the next element of the tuple in values, and the object to convert comes after the minimum field width and optional precisionPrecision [optional], given as a
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
90 [dot] followed by the precision. If specified as>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
89 [an asterisk], the actual precision is read from the next element of the tuple in values, and the value to convert comes after the precisionLength modifier [optional]
Conversion type
When the right argument is a dictionary [or other mapping type], then the formats in the string must include a parenthesised mapping key into that dictionary inserted immediately after the
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168087 character. The mapping key selects the value to be formatted from the mapping. For example
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'3
In this case no
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'00 specifiers may occur in a format [since they require a sequential parameter list]
The conversion flag characters are
Flag
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
The value conversion will use the “alternate form” [where defined below]
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168077
The conversion will be zero padded for numeric values
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168079
The converted value is left adjusted [overrides the
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168077 conversion if both are given]
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168098
[a space] A blank should be left before a positive number [or empty string] produced by a signed conversion
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168078
A sign character [
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168078 or
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168079] will precede the conversion [overrides a “space” flag]
A length modifier [
def from_bytes[bytes, byteorder='big', signed=False]: if byteorder == 'little': little_ordered = list[bytes] elif byteorder == 'big': little_ordered = list[reversed[bytes]] else: raise ValueError["byteorder must be either 'little' or 'big'"] n = sum[b >> 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]]]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 dữ liệu nhị phân bắt đầu bằng tiền tố đã chỉ định, nếu không thì trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. prefix can also be a tuple of prefixes to look for. With optional start, test beginning at that position. With optional end, stop comparing at that position
The prefix[es] to search for may be any
bytes. translate[table , / , delete=b'']bytearray. translate[table , / , delete=b'']Return a copy of the bytes or bytearray object where all bytes occurring in the optional argument delete are removed, and the remaining bytes have been mapped through the given translation table, which must be a bytes object of length 256
You can use the method to create a translation table
Set the table argument to
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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. trung tâm[chiều rộng[ , 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[[ký tự]]
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 . 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ụ
>>> [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
byte. tách[sep=Không có . , maxsplit=- 1]bytearray.tách[sep=Không có, maxsplit=- 1]Tách chuỗi nhị phân thành các chuỗi con cùng loại, sử dụng sep làm chuỗi phân cách. Nếu maxsplit được đưa ra và không âm, 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 là
>>> 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 con trống [ví dụ:
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False27 trả về
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False28]. Đối số sep có thể bao gồm một chuỗi nhiều byte [ví dụ:
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False29 trả về
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False30]. Việc tách một chuỗi trống với một dấu phân tách được chỉ định trả về
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False31 hoặc
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False32 tùy thuộc vào loại đối tượng được tách. Đối số sep có thể là bất kỳ
For example
>>> [65].to_bytes[] b'A'9
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 ASCII 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 trống hoặc một chuỗi chỉ bao gồm khoảng trắng ASCII mà không có dấu phân cách được chỉ định 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'] --> 649
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]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. Lưu ý rằng tất cả các phương thức bytearray trong phần này không hoạt động tại chỗ mà thay vào đó tạo ra các đối tượng mới
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. ] Nếu byte hiện tại là một dòng mới ASCII [
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False37] hoặc dấu xuống dòng [
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False38], nó sẽ được sao chép và cột hiện tại được đặt lại về 0. Bất kỳ giá trị byte nào khác được sao chép không thay đổi và cột hiện tại được tăng thêm một bất kể giá trị byte được biểu thị như thế nào khi in
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]2
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
byte. isalnum[]bytearray. isalnum[]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các byte trong chuỗi là ký tự ASCII theo thứ tự bảng chữ cái hoặc chữ số thập phân ASCII và chuỗi không trống, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. 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. Chữ số thập phân ASCII là những giá trị byte trong chuỗi
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False42
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]3byte. isalpha[]bytearray. isalpha[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các byte trong chuỗi là các ký tự bảng chữ cái ASCII và chuỗi không trống, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. 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
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]4byte. isascii[]bytearray. isascii[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu chuỗi trống hoặc tất cả các byte trong chuỗi là ASCII, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Các byte ASCII nằm trong khoảng 0-0x7F
New in version 3. 7
byte. isdigit[]bytearray. isdigit[]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các byte trong chuỗi là chữ số thập phân ASCII và chuỗi không trống, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Chữ số thập phân ASCII là những giá trị byte trong chuỗi
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False42
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]5byte. islower[]bytearray. giảm tốc[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu có ít nhất một ký tự ASCII chữ thường trong chuỗi và không có ký tự ASCII chữ hoa, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]6
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[] False54byte. không gian[]bytearray. không gian[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các byte trong chuỗi là khoảng trắng ASCII và chuỗi không trống, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Các ký tự khoảng trắng ASCII là các giá trị byte đó trong chuỗi
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False57 [dấu cách, tab, dòng mới, xuống dòng, tab dọc, nguồn cấp biểu mẫu]byte. tiêu đề[]bytearray. tiêu đề[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu chuỗi là chữ cái tiêu đề ASCII và chuỗi không trống, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Xem để biết thêm chi tiết về định nghĩa của “titlecase”
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]7byte. issupper[]bytearray. ăn tối[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu có ít nhất một ký tự ASCII chữ hoa trong chuỗi và không có ký tự ASCII chữ thường, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]8
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[] False54byte. lower[]bytearray. thấp hơn[]
Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ hoa được chuyển đổi thành chữ thường tương ứng của chúng
For example
def to_bytes[n, length=1, byteorder='big', signed=False]: if byteorder == 'little': order = range[length] elif byteorder == 'big': order = reversed[range[length]] else: raise ValueError["byteorder must be either 'little' or 'big'"] return bytes[[n >> i*8] & 0xff for i in order]9
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
byte. đường phân chia[keepends=Sai . ]bytearray.đường phân chia[keepends=Sai]Trả về danh sách các dòng trong chuỗi nhị phân, phá vỡ ranh giới dòng ASCII. Phương pháp này sử dụng phương pháp tách dòng. Ngắt dòng không được bao gồm trong danh sách kết quả trừ khi keepends được đưa ra và đúng
For example
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 167116800
Unlike when a delimiter string sep is given, this method returns an empty list for the empty string, and a terminal line break does not result in an extra line
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 167116801byte. swapcase[]bytearray. hoán đổi[]
Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ thường được chuyển đổi thành chữ hoa tương ứng của chúng và ngược lại
For example
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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
Không giống như , luôn luôn xảy ra trường hợp
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False71 đối với các phiên bản nhị phân. Chuyển đổi trường hợp là đối xứng trong ASCII, mặc dù điều đó thường không đúng đối với các điểm mã Unicode tùy ý
Note
The bytearray version of this method does not operate in place - it always produces a new object, even if no changes were made
byte. tiêu đề[]bytearray. tiêu đề[]Trả về phiên bản có tiêu đề của chuỗi nhị phân trong đó các từ bắt đầu bằng ký tự ASCII viết hoa và các ký tự còn lại là chữ thường. Các giá trị byte chưa được khai thác không được sửa đổi
For example
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 167116803
Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False53. Các ký tự ASCII chữ hoa là những giá trị byte trong chuỗi
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False54. Tất cả các giá trị byte khác đều không có vỏ
The algorithm uses a simple language-independent definition of a word as groups of consecutive letters. The definition works in many contexts but it means that apostrophes in contractions and possessives form word boundaries, which may not be the desired result
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 167116804
Có thể xây dựng giải pháp thay thế cho dấu nháy đơn bằng cách sử dụng biểu thức chính quy
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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
byte. trên[]bytearray. trên[]Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ thường được chuyển đổi thành chữ hoa tương ứng của chúng
For example
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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
byte. zfill[width]bytearray. zfill[chiều rộng]Trả lại một bản sao của chuỗi còn lại được điền bằng ASCII
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False76 chữ số để tạo một chuỗi có chiều dài chiều rộng. Tiền tố dấu hiệu ở đầu [
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False77/
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False78] được xử lý bằng cách chèn phần đệm sau ký tự dấu hiệu thay vì trước. Đối với các đối tượng, chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False80
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'] 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
Định dạng byte kiểu 26 kiểu def to_bytes[n, length=1, byteorder='big', signed=False]:
if byteorder == 'little':
order = range[length]
elif byteorder == 'big':
order = reversed[range[length]]
else:
raise ValueError["byteorder must be either 'little' or 'big'"]
return bytes[[n >> i*8] & 0xff for i in order]
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]. Nếu giá trị được in có thể là một bộ hoặc từ điển, hãy bọc nó trong một bộ
Các đối tượng byte [
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'23/
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'24] có một thao tác tích hợp duy nhất. toán tử
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168083 [mô-đun]. Điều này còn được gọi là định dạng byte hoặc toán tử nội suy. Cho trước
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168084 [trong đó định dạng là đối tượng byte], thông số kỹ thuật chuyển đổi của
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168083 ở định dạng được thay thế bằng 0 hoặc nhiều thành phần giá trị. Hiệu quả tương tự như việc sử dụng
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 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. Mặt khác, các giá trị phải là một bộ có số mục chính xác được chỉ định bởi đối tượng byte định dạng hoặc một đối tượng ánh xạ đơn lẻ [ví dụ: từ điển]
A conversion specifier contains two or more characters and has the following components, which must occur in this order
The
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
87 character, which marks the start of the specifierMapping 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
Minimum field width [optional]. If specified as an
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
89 [asterisk], the actual width is read from the next element of the tuple in values, and the object to convert comes after the minimum field width and optional precisionPrecision [optional], given as a
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
90 [dot] followed by the precision. If specified as>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 16711680
89 [an asterisk], the actual precision is read from the next element of the tuple in values, and the value to convert comes after the precisionLength modifier [optional]
Conversion type
Khi đối số bên phải là một từ điển [hoặc loại ánh xạ khác], thì các định dạng trong đối tượng byte phải bao gồm khóa ánh xạ trong ngoặc đơn vào từ điển đó được chèn ngay sau ký tự
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168087. Phím ánh xạ chọn giá trị được định dạng từ ánh xạ. Ví dụ
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 167116808
In this case no
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'00 specifiers may occur in a format [since they require a sequential parameter list]
The conversion flag characters are
Flag
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
The value conversion will use the “alternate form” [where defined below]
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168077
The conversion will be zero padded for numeric values
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168079
The converted value is left adjusted [overrides the
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168077 conversion if both are given]
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168098
[a space] A blank should be left before a positive number [or empty string] produced by a signed conversion
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168078
A sign character [
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168078 or
>>> int.from_bytes[b'\x00\x10', byteorder='big'] 16 >>> int.from_bytes[b'\x00\x10', byteorder='little'] 4096 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=True] -1024 >>> int.from_bytes[b'\xfc\x00', byteorder='big', signed=False] 64512 >>> int.from_bytes[[255, 0, 0], byteorder='big'] 1671168079] will precede the conversion [overrides a “space” flag]
A length modifier [
def from_bytes[bytes, byteorder='big', signed=False]: if byteorder == 'little': little_ordered = list[bytes] elif byteorder == 'big': little_ordered = list[reversed[bytes]] else: raise ValueError["byteorder must be either 'little' or 'big'"] n = sum[b 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
chỉ đọcMột bool cho biết bộ nhớ có ở chế độ chỉ đọc hay không
định dạngMột chuỗi chứa định dạng [theo kiểu mô-đun] cho từng thành phần trong dạng xem. Một chế độ xem bộ nhớ có thể được tạo từ các trình xuất với các chuỗi định dạng tùy ý, nhưng một số phương thức [e. g. ] bị hạn chế đối với các định dạng phần tử đơn gốc
Đã thay đổi trong phiên bản 3. 3. định 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'] --> 6088 hiện được xử lý theo cú pháp mô-đun cấu trúc. Điều này có nghĩa là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6089. kích thước mục
Kích thước tính bằng byte của từng phần tử của memoryview
>>> [-2.0].is_integer[] True >>> [3.2].is_integer[] False8đim
Một số nguyên cho biết có bao nhiêu chiều của một mảng nhiều chiều mà bộ nhớ đại diện
hình dạngMột bộ số nguyên có độ dài tạo ra hình dạng của bộ nhớ dưới dạng một mảng N chiều
Đã thay đổi trong phiên bản 3. 3. Một bộ trống thay vì
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631 khi ndim = 0. strides
Một bộ số nguyên có độ dài đưa ra kích thước theo byte để truy cập từng phần tử cho từng chiều của mảng
Đã thay đổi trong phiên bản 3. 3. Một bộ trống thay vì
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631 khi ndim = 0. bù trừ
Được sử dụng nội bộ cho các mảng kiểu PIL. Giá trị chỉ là thông tin
c_contigiousMột bool cho biết liệu bộ nhớ có phải là C-
New in version 3. 3
f_tiếp giápMột bool cho biết bộ nhớ có phải là Fortran hay không
New in version 3. 3
tiếp giápMột bool cho biết liệu bộ nhớ có
New in version 3. 3
Đặt loại — ,
Một đối tượng tập hợp là một tập hợp không có thứ tự của các đối tượng riêng biệt. Các ứng dụng phổ biến bao gồm kiểm tra tư cách thành viên, loại bỏ các bản sao khỏi chuỗi và tính toán các phép toán như giao, hợp, hiệu và hiệu đối xứng. [Đối với các bộ chứa khác, hãy xem các lớp , , và tích hợp sẵn và mô-đun. ]
Giống như các bộ sưu tập khác, các bộ hỗ trợ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 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'] --> 6102. Là một tập hợp không có thứ tự, các tập hợp không ghi vị trí phần tử hoặc thứ tự chèn. Theo đó, các bộ không hỗ trợ lập chỉ mục, cắt hoặc hành vi giống như trình tự khác
Hiện tại có hai loại thiết lập tích hợp và. Loại có thể thay đổi — nội dung có thể được thay đổi bằng các phương thức như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6106 và
>>> [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
Ví dụ: có thể tạo các tập hợp không trống [không phải tập hợp cố định] bằng cách đặt danh sách các phần tử được phân tách bằng dấu phẩy trong dấu ngoặc nhọn.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6109, ngoài hàm tạo
Các hàm tạo cho cả hai lớp hoạt động như nhau
lớp bộ[[có thể lặp lại]]class frozenset[[iterable]]Trả về một đối tượng set hoặc freezeset mới có các phần tử được lấy từ iterable. Các phần tử của một tập hợp phải. Để biểu diễn các tập hợp, các tập hợp bên trong phải là các đối tượng. Nếu iterable không được chỉ định, một bộ trống mới được trả về
Các bộ có thể được tạo bằng nhiều cách
Sử dụng danh sách các phần tử được phân tách bằng dấu phẩy trong dấu ngoặc nhọn.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
109Sử dụng một bộ hiểu.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
113Sử dụng hàm tạo kiểu.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
51,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
115,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
116
Các trường hợp và cung cấp các hoạt động sau
[các] ống kínhTrả về số phần tử trong tập hợp s [số lượng của s]
x in sKiểm tra x cho tư cách thành viên trong s
x not in sKiểm tra x cho người không phải là thành viên trong s
isdisjoint[khác]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tập hợp không có phần tử nào chung với tập hợp khác. Các tập hợp là rời nhau khi và chỉ khi giao của chúng là tập hợp rỗngissubset[other]set 6 120issuperset[other]set >= other
Kiểm tra xem mọi phần tử trong tập hợp khác có nằm trong tập hợp không
đặt > khácKiểm tra xem tập hợp này có phải là tập hợp lớn nhất của tập hợp khác hay không, nghĩa là,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6121công đoàn[*những người khác]set | khác . .
Trả về một tập hợp mới với các phần tử từ tập hợp và tất cả các phần tử khác
giao lộ[*các ngã tư khác]set & other & ...Trả về một tập hợp mới với các phần tử chung cho tập hợp và tất cả các phần tử khác
difference[*others]set - other - .Trả về một tập hợp mới với các phần tử trong tập hợp không có trong các phần tử khác
symmetric_difference[khác]đặt ^ otherTrả về một tập hợp mới có các phần tử trong tập hợp này hoặc tập hợp khác nhưng không phải cả hai
bản sao[]Trả lại một bản sao nông của tập hợp
Lưu ý, các phiên bản không phải toán tử của , , , , và các phương thức sẽ chấp nhận bất kỳ lần lặp nào làm đối số. Ngược lại, các đối tác dựa trên toán tử của chúng yêu cầu các đối số của chúng được đặt. Điều này loại bỏ các cấu trúc dễ bị lỗi như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6128 để có thể đọc dễ dàng hơn
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6129
Cả hai và bộ hỗ trợ để đặt so sánh. Hai tập hợp bằng nhau khi và chỉ khi mọi phần tử của mỗi tập hợp đều chứa trong tập hợp kia [mỗi tập hợp này là tập con của tập hợp kia]. Một tập hợp nhỏ hơn tập hợp khác khi và chỉ khi tập hợp đầu tiên là tập hợp con thực sự của tập hợp thứ hai [là tập hợp con, nhưng không bằng nhau]. Một tập hợp lớn hơn tập hợp khác khi và chỉ khi tập hợp đầu tiên là tập hợp lớn nhất của tập hợp thứ hai [là tập hợp phụ, nhưng không bằng nhau]
Các trường hợp được so sánh với các trường hợp dựa trên các thành viên của chúng. Ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6134 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 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'] --> 6136 cũng vậy
So sánh tập hợp con và đẳng thức không tổng quát hóa thành hàm sắp xếp tổng. Ví dụ: hai tập hợp khác nhau bất kỳ không rỗng thì không bằng nhau và không phải là tập con của nhau, vì vậy tất cả các giá trị sau trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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, 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'] --> 6140
Vì các tập hợp chỉ xác định thứ tự một phần [mối quan hệ tập hợp con], nên đầu ra của phương thức không được xác định cho danh sách các tập hợp
Set elements, like dictionary keys, must be
Các hoạt động nhị phân kết hợp các trường hợp với trả về loại toán hạng đầu tiên. Ví dụ.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6144 trả về một thể hiện của
Bảng sau đây liệt kê các hoạt động khả dụng không áp dụng cho các trường hợp bất biến của
cập nhật[*khác]set |= khác . .Cập nhật tập hợp, thêm các phần tử từ tất cả các phần tử khác
intersection_update[*khác]set &= other & ...Cập nhật tập hợp, chỉ giữ lại các phần tử được tìm thấy trong đó và tất cả các phần tử khác
difference_update[*khác]set -= other | .Cập nhật tập hợp, loại bỏ các phần tử được tìm thấy trong các tập hợp khác
symmetric_difference_update[khác]đặt ^= otherCập nhật tập hợp, chỉ giữ lại các phần tử được tìm thấy trong một trong hai tập hợp chứ không phải trong cả hai
add[elem]Thêm phần tử elem vào tập hợp
xóa[elem]Xóa phần tử elem khỏi tập hợp. Tăng nếu elem không được chứa trong tập hợp
loại bỏ[elem]Xóa phần tử elem khỏi tập hợp nếu có
bốp[]Xóa và trả về một phần tử tùy ý khỏi tập hợp. Tăng nếu bộ trống
xóa[]Xóa tất cả các phần tử khỏi tập hợp
Lưu ý, các phiên bản không phải toán tử của các phương thức , , và sẽ chấp nhận bất kỳ lần lặp nào làm đối số
Lưu ý, đối số elem của phương thức
>>> n = 19 >>> bin[n] '0b10011' >>> n.bit_count[] 3 >>> [-n].bit_count[] 300, , và có thể là một tập hợp. Để hỗ trợ tìm kiếm một bộ đóng băng tương đương, một bộ tạm thời được tạo từ elem
Các loại ánh xạ —
Một đối tượng ánh xạ các giá trị tới các đối tượng tùy ý. Ánh xạ là các đối tượng có thể thay đổi. Hiện tại chỉ có một loại ánh xạ tiêu chuẩn, từ điển. [Đối với các bộ chứa khác, hãy xem các lớp , , và tích hợp sẵn và mô-đun. ]
A dictionary’s keys are almost arbitrary values. Các giá trị không phải là , nghĩa là các giá trị chứa danh sách, từ điển hoặc các loại có thể thay đổi khác [được so sánh theo giá trị thay vì theo danh tính đối tượng] có thể không được sử dụng làm khóa. Các giá trị so sánh bằng nhau [chẳng hạn như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 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] có thể được sử dụng thay thế cho nhau để lập chỉ mục cho cùng một mục từ điểnclass dict[**kwargs]class dict[mapping, **kwargs]class dict[iterable, **kwargs]
Trả về một từ điển mới được khởi tạo từ một đối số vị trí tùy chọn và một bộ đối số từ khóa có thể trống
Từ điển có thể được tạo ra bằng nhiều cách
Sử dụng danh sách các cặp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
165 được phân tách bằng dấu phẩy trong dấu ngoặc nhọn.def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
166 hoặcdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
167Sử dụng hiểu chính tả.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
50,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
169Sử dụng hàm tạo kiểu.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
170,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
171,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
172
Nếu không có đối số vị trí nào được đưa ra, một từ điển trống sẽ được tạo. Nếu một đối số vị trí được đưa ra và nó là một đối tượng ánh xạ, thì một từ điển sẽ được tạo với các cặp khóa-giá trị giống như đối tượng ánh xạ. Mặt khác, đối số vị trí phải là một đối tượng. Bản thân mỗi mục trong iterable phải là iterable với chính xác hai đối tượng. Đối tượng đầu tiên của mỗi mục trở thành một khóa trong từ điển mới và đối tượng thứ hai là giá trị tương ứng. Nếu một khóa xuất hiện nhiều lần, giá trị cuối cùng của khóa đó sẽ trở thành giá trị tương ứng trong từ điển mới
Nếu các đối số từ khóa được đưa ra, thì các đối số từ khóa và giá trị của chúng sẽ được thêm vào từ điển được tạo từ đối số vị trí. Nếu một khóa đang được thêm đã xuất hiện, thì giá trị từ đối số từ khóa sẽ thay thế giá trị từ đối số vị trí
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
Việc cung cấp các đối số từ khóa như trong ví dụ đầu tiên chỉ hoạt động đối với các khóa là mã định danh Python hợp lệ. Mặt khác, bất kỳ khóa hợp lệ nào cũng có thể được sử dụng
Đây là các hoạt động mà từ điển hỗ trợ [và do đó, các loại ánh xạ tùy chỉnh cũng sẽ hỗ trợ]
danh sách[d]Trả về danh sách tất cả các khóa được sử dụng trong từ điển d
cho vay]Trả về số mục trong từ điển d
đ[phím]Trả lại mục của d bằng phím key. Tăng phím nếu không có trong bản đồ
Nếu một lớp con của dict định nghĩa một phương thức
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6175 và không có khóa, thì thao tác
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6176 gọi phương thức đó với đối số là key key. Hoạt động
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6176 sau đó trả lại hoặc tăng bất cứ thứ gì được trả lại hoặc tăng bởi lệnh gọi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6178. Không có hoạt động hoặc phương pháp nào khác gọi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6175. 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'] --> 6175 không được xác định, được nâng lên.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6175 phải là một phương thức;
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 600
Ví dụ trên cho thấy một phần của việc thực hiện. Một phương pháp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6184 khác được sử dụng bởid[key] = giá trị
Đặt
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6176 thành giá trịdel d[key]
Xóa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6176 khỏi d. Tăng phím nếu không có trong bản đồphím vào d
Trả lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu d có khóa chính, ngược lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638phím không vào d
Tương đương với
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6191lặp đi lặp lại [d]
Trả lại một trình vòng lặp qua các khóa của từ điển. Đây là lối tắt cho
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6192xóa[]
Xóa tất cả các mục khỏi từ điển
bản sao[]Trả lại một bản sao nông của từ điển
phương thức lớp từ khóa[có thể lặp lại[, value]]Tạo một từ điển mới với các khóa từ iterable và các giá trị được đặt thành giá trị
là một phương thức lớp trả về một từ điển mới. giá trị mặc định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631. Tất cả các giá trị chỉ tham chiếu đến một thể hiện duy nhất, do đó, thông thường giá trị là một đối tượng có thể thay đổi chẳng hạn như một danh sách trống không có ý nghĩa gì. Để nhận các giá trị riêng biệt, hãy sử dụng thay thếlấy[khóa[ , default]]
Trả về giá trị cho khóa nếu khóa có trong từ điển, nếu không thì mặc định. Nếu giá trị mặc định không được đưa ra, nó sẽ mặc định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, do đó phương thức này không bao giờ tăngitems[]
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]. xemphím[]
Trả lại chế độ xem mới cho các khóa của từ điển. xem
bật[phím[ , default]]Nếu khóa nằm trong từ điển, hãy xóa nó và trả về giá trị của nó, nếu không thì trả về giá trị mặc định. Nếu giá trị mặc định không được cung cấp và khóa không có trong từ điển, a sẽ tăng
popitem[]Xóa và trả về cặp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 ý.
đảo ngược[d]Trả về một trình vòng lặp đảo ngược trên các khóa của từ điển. Đây là lối tắt cho
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6204
New in version 3. 8
setdefault[key[ , default]]Nếu khóa nằm trong từ điển, hãy trả về giá trị của nó. Nếu không, hãy chèn khóa có giá trị mặc định và trả về giá trị mặc định. mặc định 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'] --> 631cập nhật[[khác]]
Cập nhật từ điển với các cặp khóa/giá trị từ khác, ghi đè lên các khóa hiện có. Trả lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631
chấp nhận một đối tượng từ điển khác hoặc một cặp khóa/giá trị có thể lặp lại [dưới dạng bộ dữ liệu hoặc các lần lặp khác có độ dài hai]. Nếu các đối số từ khóa được chỉ định, thì từ điển sẽ được cập nhật với các cặp khóa/giá trị đó.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6208giá trị[]
Trả lại chế độ xem mới về các giá trị của từ điển. xem
So sánh bình đẳng giữa một chế độ xem
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6209 và chế độ xem khác sẽ luôn trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Điều này cũng áp dụng khi so sánh
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6209 với chính nó
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 601d . khác
Tạo một từ điển mới với các khóa và giá trị được hợp nhất của d và khác, cả hai phải là từ điển. Các giá trị của other được ưu tiên khi d và các khóa chia sẻ khác
New in version 3. 9
d . = khácCập nhật từ điển d với các khóa và giá trị từ từ khác, có thể là a hoặc một trong các cặp khóa/giá trị. Các giá trị của other được ưu tiên khi d và các khóa chia sẻ khác
New in version 3. 9
Dictionaries compare equal if and only if they have the same
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6197 pairs [regardless of ordering]. Order comparisons [‘’] raise .
Từ điển bảo toàn thứ tự chèn. Lưu ý rằng việc cập nhật khóa không ảnh hưởng đến thứ tự. Các phím được thêm sau khi xóa được chèn vào cuối
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 602
Changed in version 3. 7. Thứ tự từ điển được đảm bảo là thứ tự chèn. Hành vi này là một chi tiết triển khai của CPython từ 3. 6.
Từ điển và chế độ xem từ điển có thể đảo ngược
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 603
Đã thay đổi trong phiên bản 3. 8. Từ điển hiện có thể đảo ngược.
See also
có thể được sử dụng để tạo chế độ xem chỉ đọc của một
Các đối tượng xem từ điển
Các đối tượng được trả về và là các đối tượng xem. Chúng cung cấp chế độ xem động cho các mục nhập của từ điển, có nghĩa là khi từ điển thay đổi, chế độ xem sẽ phản ánh những thay đổi này
Chế độ xem từ điển có thể được lặp đi lặp lại để mang lại dữ liệu tương ứng và hỗ trợ kiểm tra tư cách thành viên
len[dictview]Trả về số mục trong từ điển
lặp đi lặp lại [dictview]Trả về một trình vòng lặp trên các khóa, giá trị hoặc mục [được biểu thị dưới dạng bộ dữ liệu của
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6197] trong từ điển
Các khóa và giá trị được lặp lại theo thứ tự chèn. Điều này cho phép tạo ra các cặp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6220 bằng cách sử 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'] --> 6222. Một cách khác để tạo danh sách tương tự là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6223
Lặp lại các dạng xem trong khi thêm hoặc xóa các mục trong từ điển có thể gây ra hoặc không thể lặp lại trên tất cả các mục
Đã thay đổi trong phiên bản 3. 7. Dictionary order is guaranteed to be insertion order.
x in dictviewTrả 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 x nằm trong các khóa, giá trị hoặc mục của từ điển cơ sở [trong trường hợp sau, x phải là bộ dữ liệ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'] --> 6197]đảo ngược [dictview]
Trả về một trình lặp đảo ngược trên các khóa, giá trị hoặc mục của từ điển. Chế độ xem sẽ được lặp lại theo thứ tự ngược lại của phần chèn
Đã thay đổi trong phiên bản 3. 8. Chế độ xem từ điển hiện có thể đảo ngược.
chế độ xem chính tả. lập bản đồTrả lại a bao bọc từ điển gốc mà chế độ xem đề cập đến
Mới trong phiên bản 3. 10
Chế độ xem khóa giống như được đặt vì các mục nhập của chúng là duy nhất và có thể băm. Nếu tất cả các giá trị đều có thể băm, để các cặp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6197 là duy nhất và có thể băm, thì chế độ xem các mục cũng giống như được đặt. [Chế độ xem giá trị không được coi là giống như tập hợp vì các mục thường không phải là duy nhất. ] Đối với các khung nhìn dạng tập hợp, tất cả các thao tác được định nghĩa cho lớp cơ sở trừu tượng đều khả dụng [ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 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'] --> 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
Các loại trình quản lý bối cảnh
Câu lệnh của Python hỗ trợ khái niệm bối cảnh thời gian chạy được xác định bởi trình quản lý bối cảnh. Điều này được thực hiện bằng cách sử dụng một cặp phương thức cho phép các lớp do người dùng định nghĩa xác định bối cảnh thời gian chạy được nhập vào trước khi phần thân câu lệnh được thực thi và thoát khi câu lệnh kết thúc
trình quản lý ngữ cảnh. __enter__[]Nhập bối cảnh thời gian chạy và trả về đối tượng này hoặc đối tượng khác liên quan đến bối cảnh thời gian chạy. Giá trị được phương thức này trả về được liên kết với mã định danh trong mệnh đề
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6234 của các câu lệnh sử dụng trình quản lý ngữ cảnh này
Một ví dụ về trình quản lý bối cảnh tự trả về là một. Các đối tượng tệp tự trả về từ __enter__[] để cho phép được sử dụng làm biểu thức ngữ cảnh trong câu lệnh
Một ví dụ về trình quản lý bối cảnh trả về một đối tượng liên quan là đối tượng được trả về bởi. Các trình quản lý này đặt ngữ cảnh thập phân đang hoạt động thành một bản sao của ngữ cảnh thập phân ban đầu rồi trả lại bản sao. Điều này cho phép thực hiện các thay đổi đối với ngữ cảnh thập phân hiện tại trong phần thân của câu lệnh mà không ảnh hưởng đến mã bên ngoài câu lệnh
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6081trình quản lý ngữ cảnh. __exit__[exc_type , exc_val, exc_tb]
Thoát khỏi bối cảnh thời gian chạy và trả về một cờ Boolean cho biết liệu có nên loại bỏ bất kỳ ngoại lệ nào xảy ra hay không. Nếu một ngoại lệ xảy ra trong khi thực thi phần thân của câu lệnh, thì các đối số chứa loại ngoại lệ, giá trị và thông tin truy nguyên. Mặt khác, cả ba đối số đều là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631
Returning a true value from this method will cause the statement to suppress the exception and continue execution with the statement immediately following 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 statement. Mặt khác, ngoại lệ tiếp tục lan truyền sau khi phương thức này thực hiện xong. Các ngoại lệ xảy ra trong quá trình thực thi phương thức này sẽ thay thế bất kỳ ngoại lệ nào xảy ra trong phần thân của câu lệnh
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6081
Ngoại lệ được truyền vào không bao giờ được gọi lại một cách rõ ràng - thay vào đó, phương thức này sẽ trả về một giá trị sai để cho biết rằng phương thức đã hoàn tất thành công và không muốn chặn ngoại lệ đã nêu. Điều này cho phép mã quản lý bối cảnh dễ dàng phát hiện xem một phương thức có thực sự bị lỗi hay không
Python định nghĩa một số trình quản lý ngữ cảnh để hỗ trợ đồng bộ hóa luồng dễ dàng, đóng nhanh tệp hoặc các đối tượng khác và thao tác đơn giản hơn đối với ngữ cảnh số học thập phân đang hoạt động. Các loại cụ thể không được xử lý đặc biệt ngoài việc thực hiện giao thức quản lý ngữ cảnh. Xem mô-đun để biết một số ví dụ
Python's và trình trang trí cung cấp một cách thuận tiện để triển khai các giao thức này. Nếu một hàm tạo được trang trí bằng trình tạo trang trí, thì nó sẽ trả về trình quản lý bối cảnh thực hiện các phương thức và cần thiết, thay vì trình vòng lặp được tạo bởi hàm tạo không được trang trí
Lưu ý rằng không có vị trí cụ thể nào cho bất kỳ phương thức nào trong số này trong cấu trúc kiểu cho các đối tượng Python trong API Python/C. Các loại tiện ích mở rộng muốn xác định các phương thức này phải cung cấp chúng như một phương thức truy cập Python bình thường. So với chi phí thiết lập bối cảnh thời gian chạy, chi phí hoạt động của một tra cứu từ điển một lớp là không đáng kể
Nhập các loại chú thích — ,
Các loại tích hợp sẵn cốt lõi cho are và
Loại bí danh chung
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 đối tượng thường được tạo bởi một lớp. Chúng thường được sử dụng với , chẳng hạn như hoặc. Ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6255 là một đối tượng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 được tạo bằng cách đăng ký lớp
def bit_count[self]: return bin[self].count["1"]93 với đối số.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 đối tượng được dự định chủ yếu để sử dụng với
Note
It is generally only possible to subscript a class if the class implements the special method
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
Đối với một lớp chứa, [các] đối số được cung cấp cho một lớp có thể chỉ ra [các] loại phần tử mà một đối tượng chứa. Ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6262 có thể được sử dụng trong chú thích loại để biểu thị một trong đó tất cả các phần tử đều thuộc loại
Đối với một lớp định nghĩa nhưng không phải là một vùng chứa, [các] đối số được cung cấp cho đăng ký của lớp thường sẽ chỉ ra [các] kiểu trả về của một hoặc nhiều phương thức được xác định trên một đối tượng. 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, . ]
Tạo một
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 đại diện cho một loại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6289 được tham số hóa bởi các loại X, Y, v.v. tùy thuộc vào
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6289 được sử dụng. Ví dụ: một hàm mong đợi một phần tử chứa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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ị. Trong ví dụ này, hàm mong đợi một
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'68 với các khóa thuộc loại và các giá trị thuộc loại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
Thời gian chạy Python không thực thi. Điều này mở rộng đến các loại chung và các tham số loại của chúng. Khi tạo đối tượng vùng chứa 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'] --> 6252, các phần tử trong vùng chứa không được kiểm tra đối với loại của chúng. Ví dụ: đoạn mã sau không được khuyến khích nhưng sẽ chạy không có lỗi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 608
Hơn nữa, các tham số loại được tham số hóa xóa các tham số loại trong quá trình tạo đối tượng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 609
Gọi hoặc trên chung hiển thị loại được tham số hóa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 610
Phương pháp của các thùng chứa chung sẽ đưa ra một ngoại lệ để không cho phép các lỗi như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
Tuy nhiên, các biểu thức như vậy có giá trị khi được sử dụng. Chỉ mục phải có nhiều phần tử bằng với số mục biến loại trong đối tượng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252
def bit_length[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
Các lớp chung tiêu chuẩn
Các lớp thư viện tiêu chuẩn sau đây hỗ trợ các generic được tham số hóa. danh sách này là không đầy đủ
Thuộc tính đặc biệt của def bit_length[self]:
s = bin[self] # binary representation: bin[-37] --> '-0b100101'
s = s.lstrip['-0b'] # remove leading zeros and minus sign
return len[s] # len['100101'] --> 6
252 đối tượng
Tất cả các generic được tham số hóa đều triển khai các thuộc tính chỉ đọc đặc biệt
tên chung. __origin__Thuộc tính này trỏ đến lớp chung không tham số hóa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 613tên chung. __args__
Thuộc tính này là [có thể có độ dài 1] của các loại chung được truyền cho bản gốc của lớp chung
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 614tên chung. __tham số__
Thuộc tính này là một bộ được tính toán chậm [có thể trống] gồm các biến loại duy nhất được tìm thấy trong
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
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 với các tham số có thể không đúng với
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6365 sau khi thay thế vì mục đích chủ yếu là để kiểm tra kiểu tĩnhtên chung. __unpacked__
Một giá trị boolean đúng nếu bí danh đã được giải nén bằng cách sử dụng toán tử
>>> [1024].to_bytes[2, byteorder='big'] b'\x04\x00' >>> [1024].to_bytes[10, byteorder='big'] b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> [-1024].to_bytes[10, byteorder='big', signed=True] b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes[[x.bit_length[] + 7] // 8, byteorder='little'] b'\xe8\x03'00 [xem phần ]
Mới trong phiên bản 3. 11
See also
PEP 484 - Gợi ý loạiGiới thiệu khung của Python cho các chú thích loại
PEP 585 - Nhập gợi ý Generics trong bộ sưu tập tiêu chuẩnIntroducing the ability to natively parameterize standard-library classes, provided they implement the special class method
, VàTài liệu về cách triển khai các lớp chung có thể được tham số hóa trong thời gian chạy và được hiểu bởi trình kiểm tra kiểu tĩnh
New in version 3. 9
Loại liên minh
Một đối tượng hợp lưu giữ giá trị của phép toán
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6371 [theo bit hoặc] trên nhiều. Các loại này chủ yếu dành cho. Biểu thức kiểu kết hợp cho phép cú pháp gợi ý kiểu sạch hơn so vớiX . Y . .
Xác định một đối tượng kết hợp chứa các loại X, Y, v.v.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6373 có nghĩa là X hoặc Y. Nó tương đương với
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6374. Ví dụ: hàm sau mong đợi một đối số kiểu hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 616union_object == khác
Các đối tượng kết hợp có thể được kiểm tra sự bình đẳng với các đối tượng kết hợp khác. Chi tiết
Liên minh công đoàn bị san bằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
17Các loại dư thừa được loại bỏ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
18Khi so sánh các công đoàn, thứ tự bị bỏ qua
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
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
Các loại tích hợp khác
Trình thông dịch hỗ trợ một số loại đối tượng khác. Hầu hết trong số này chỉ hỗ trợ một hoặc hai thao tác
mô-đun
Hoạt động đặc biệt duy nhất trên một mô-đun là truy cập thuộc tính.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6387, trong đó m là một mô-đun và tên truy cập vào tên được xác định trong bảng ký hiệu của m. Thuộc tính mô-đun có thể được gán cho. [Lưu ý rằng câu lệnh, nói đúng ra, không phải là một thao tác trên một đối tượng mô-đun;
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6389 không yêu cầu một đối tượng mô-đun có tên foo tồn tại, thay vào đó, nó yêu cầu một định nghĩa [bên ngoài] cho một mô-đun có tên foo ở đâu đó. ]
Một thuộc tính đặc biệt của mỗi mô-đun là. Đây là từ điển chứa bảng ký hiệu của module. Sửa đổi từ điển này sẽ thực sự thay đổi bảng ký hiệu của mô-đun, nhưng không thể gán trực tiếp cho thuộc tính [bạn có thể viết
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6392, định nghĩa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6393 là ________0____55, nhưng bạn không thể viết
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6395]. Sửa đổi trực tiếp không được khuyến khích
Các mô-đun được tích hợp trong trình thông dịch được viết như thế này.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6397. Nếu được tải từ một tệp, chúng được viết là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6398
Các lớp và trường hợp lớp
Xem và cho những
Functions
Các đối tượng hàm được tạo bởi các định nghĩa hàm. Thao tác duy nhất trên một đối tượng hàm là gọi nó.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6399
Thực sự có hai hương vị của các đối tượng chức năng. chức năng tích hợp và chức năng do người dùng định nghĩa. Cả hai đều hỗ trợ cùng một thao tác [để gọi hàm], nhưng cách thực hiện khác nhau, do đó các loại đối tượng khác nhau
Xem để biết thêm thông tin
phương pháp
Phương thức là các hàm được gọi bằng cách sử dụng ký hiệu thuộc tính. Có hai hương vị. các phương thức tích hợp sẵn [chẳng hạn như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6400 trong danh sách] và các phương thức thể hiện của lớp. Các phương thức tích hợp được mô tả với các loại hỗ trợ chúng
Nếu bạn truy cập một phương thức [một hàm được xác định trong không gian tên lớp] thông qua một thể hiện, bạn sẽ nhận được một đối tượng đặc biệt. một đối tượng phương thức ràng buộc [còn gọi là phương thức thể hiện]. 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. Các phương thức ràng buộc có hai thuộc tính chỉ đọc đặc biệt.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6402 là đối tượng mà phương thức hoạt động 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'] --> 6403 là hàm thực thi phương thức. Gọi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6404 hoàn toàn tương đương với gọi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6405
Giống như các đối tượng hàm, các đối tượng phương thức ràng buộc hỗ trợ nhận các thuộc tính tùy ý. Tuy nhiên, vì các thuộc tính của phương thức thực sự được lưu trữ trên đối tượng chức năng bên dưới [
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6406], nên việc đặt các thuộc tính của phương thức trên các phương thức bị ràng buộc là không được phép. Cố gắng đặt một thuộc tính trên một phương thức dẫn đến việc tăng. Để đặt một thuộc tính phương thức, bạn cần đặt nó một cách rõ ràng trên đối tượng hàm bên dưới
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 626
Xem để biết thêm thông tin
đối tượng mã
Các đối tượng mã được triển khai sử dụng để biểu thị mã Python thực thi được "biên dịch giả" chẳng hạn như thân hàm. Chúng khác với các đối tượng chức năng vì chúng không chứa tham chiếu đến môi trường thực thi toàn cầu của chúng. Các đối tượng mã được hàm tích hợp trả về và có thể được trích xuất từ các đối tượng hàm thông qua thuộc tính
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6409 của chúng. Xem thêm mô-đun
Truy 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'] --> 6409 tăng một
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6412 với các đối số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6413 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'] --> 6414
Một đối tượng mã có thể được thực thi hoặc đánh giá bằng cách chuyển nó [thay vì chuỗi nguồn] tới hoặc các hàm dựng sẵn
Xem để biết thêm thông tin
Loại đối tượng
Loại đối tượng đại diện cho các loại đối tượng khác nhau. Loại đối tượng được truy cập bởi chức năng tích hợp. Không có thao tác đặc biệt nào trên các loại. Mô-đun tiêu chuẩn xác định tên cho tất cả các loại tích hợp tiêu chuẩn
Các loại được viết như thế này. ______________419
Đối tượng Null
Đối tượng này được trả về bởi các hàm không trả về giá trị một cách rõ ràng. Nó không hỗ trợ các hoạt động đặc biệt. Có chính xác một đối tượng null, tên 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 [tên dựng sẵ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'] --> 6421 tạo ra cùng một 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'] --> 631
The Ellipsis Object
Đối tượng này thường được sử dụng bằng cách cắt lát [xem ]. Nó không hỗ trợ các hoạt động đặc biệt. Có chính xác một đối tượng dấu chấm lửng, được đặt tên [tên tích hợp].
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6424 sản xuất singleton
Nó được viết là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6423 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'] --> 6427
Đối tượng không được triển khai
Đối tượng này được trả về từ phép so sánh và phép toán nhị phân khi chúng được yêu cầu thao tác trên các loại mà chúng không hỗ trợ. Xem để biết thêm thông tin. Có chính xác một đối tượng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6428.
def bit_length[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 tạo ra cá thể đơn lẻ
Nó được viết là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6428
Giá trị Boolean
Giá trị Boolean là hai đối tượng hằng số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 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. Chúng được sử dụng để biểu thị giá trị thật [mặc dù các giá trị khác cũng có thể được coi là sai hoặc đúng]. Trong ngữ cảnh số [ví dụ: khi được sử dụng làm đối số cho toán tử số học], chúng hoạt động giống như các số nguyên 0 và 1 tương ứng. Hàm tích hợp có thể được sử dụng để chuyển đổi bất kỳ giá trị nào thành Boolean, nếu giá trị đó có thể được hiểu là giá trị thực [xem phần ở trên]
Chúng được viết lần lượt là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 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
Đối tượng bên trong
Xem thông tin này. It describes stack frame objects, traceback objects, and slice objects
Thuộc tính đặc biệt
Việc triển khai thêm một vài thuộc tính chỉ đọc đặc biệt cho một số loại đối tượng, nơi chúng có liên quan. Một số trong số này không được báo cáo bởi chức năng tích hợp
đối tượng. __dict__Từ điển hoặc đối tượng ánh xạ khác được sử dụng để lưu trữ các thuộc tính [có thể ghi] của đối tượng
ví dụ. __class__Lớp mà một thể hiện của lớp thuộc về
lớp. __base__Bộ các lớp cơ sở của một đối tượng lớp
định nghĩa. __name__Tên của lớp, hàm, phương thức, bộ mô tả hoặc thể hiện của trình tạo
định nghĩa. __tên_số__Thể hiện của lớp, hàm, phương thức, bộ mô tả hoặc trình tạo
New in version 3. 3
lớp. __mro__Thuộc tính này là một bộ các lớp được xem xét khi tìm kiếm các lớp cơ sở trong quá trình phân giải phương thức
lớp. mro[]Phương thức này có thể được ghi đè bởi một siêu dữ liệu để tùy chỉnh thứ tự phân giải phương thức cho các phiên bản của nó. Nó được gọi khi khởi tạo lớp và kết quả của nó được lưu trữ trong
lớp. __phân lớp__[]Mỗi lớp giữ một danh sách các tham chiếu yếu đến các lớp con trực tiếp của nó. Phương thức này trả về một danh sách tất cả các tham chiếu vẫn còn tồn tại. Danh sách theo thứ tự định nghĩa. Ví dụ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 627
Giới hạn độ dài chuyển đổi chuỗi số nguyên
CPython có giới hạn toàn cầu để chuyển đổi giữa và để giảm thiểu các cuộc tấn công từ chối dịch vụ. Giới hạn này chỉ áp dụng cho cơ số thập phân hoặc cơ số không phải lũy thừa hai. Chuyển đổi thập lục phân, bát phân và nhị phân là không giới hạn. Giới hạn có thể được cấu hình
Loại trong Python là một số có độ dài tùy ý được lưu trữ ở dạng nhị phân [thường được gọi là “bignum”]. Không tồn tại thuật toán nào có thể chuyển đổi một chuỗi thành một số nguyên nhị phân hoặc một số nguyên nhị phân thành một chuỗi trong thời gian tuyến tính, trừ khi cơ số là lũy thừa của 2. Ngay cả các thuật toán được biết đến nhiều nhất cho cơ số 10 cũng có độ phức tạp bậc hai. 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
Giới hạn kích thước chuyển đổi cung cấp một cách thiết thực để tránh CVE-2020-10735
Giới hạn được áp dụng cho số ký tự chữ số trong chuỗi đầu vào hoặc đầu ra khi sử dụng thuật toán chuyển đổi phi tuyến tính. Dấu gạch dưới và dấu không được tính vào giới hạn
Khi một hoạt động sẽ vượt quá giới hạn, a được nâng lên
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 628
Giới hạn mặc định là 4300 chữ số như được cung cấp trong. Giới hạn thấp nhất có thể được cấu hình là 640 chữ số như được cung cấp trong
xác minh
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 629
Mới trong phiên bản 3. 11
API bị ảnh hưởng
Giới hạn chỉ áp dụng cho các chuyển đổi có khả năng chậm giữa và hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
448 với cơ số mặc định là 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 cho tất cả các cơ số không phải là lũy thừa của 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
451bất kỳ chuyển đổi chuỗi nào khác sang cơ số 10, ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
452,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
453 hoặcdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
454
Các giới hạn không áp dụng cho các hàm có thuật toán tuyến tính
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
449 với cơ số 2, 4, 8, 16 hoặc 32Và
, ,
cho các số hex, bát phân và nhị phân
ĐẾN
ĐẾN
Định cấu hình giới hạn
Trước khi Python khởi động, bạn có thể sử dụng biến môi trường hoặc cờ dòng lệnh của trình thông dịch để định cấu hình giới hạn
, e. g.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
466 để đặt giới hạn thành 640 hoặcdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
467 để tắt giới hạn, e. g.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
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 chứa giá trị của hoặc. 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. Giá trị -1 cho biết rằng cả hai đều không được đặt, do đó, giá trị ____0_______443 đã được sử dụng trong quá trình khởi tạo
Từ mã, bạn có thể kiểm tra giới hạn hiện tại và đặt giới hạn mới bằng các API này
và là một getter và setter cho giới hạn trên toàn trình thông dịch. Phiên dịch viên phụ có giới hạn riêng của họ
Thông tin về mặc định và tối thiểu có thể được tìm thấy trong
là giới hạn mặc định được biên dịch
là giá trị thấp nhất được chấp nhận cho giới hạn [khác 0 sẽ vô hiệu hóa giới hạn đó]
Mới trong phiên bản 3. 11
thận trọng
Đặt giới hạn thấp có thể dẫn đến sự cố. Mặc dù hiếm gặp, mã tồn tại chứa các hằng số nguyên ở dạng thập phân trong nguồn của chúng vượt quá ngưỡng tối thiểu. 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. Một giải pháp thay thế cho nguồn chứa các hằng số lớn như vậy là chuyển đổi chúng sang dạng thập lục phân
def bit_count[self]: return bin[self].count["1"]12 vì nó không có giới hạn
Kiểm tra ứng dụng của bạn kỹ lưỡng nếu bạn sử dụng giới hạn thấp. Đảm bảo các thử nghiệm của bạn chạy với giới hạn được đặt sớm thông qua môi trường hoặc cờ để nó áp dụng trong quá trình khởi động và thậm chí trong bất kỳ bước cài đặt nào có thể gọi Python để biên dịch trước các nguồn
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6484 thành tệp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6482
Cấu hình đề xuất
Giá trị mặc định
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6443 dự kiến sẽ hợp lý cho hầu hết các ứng dụng. Nếu ứng dụng của bạn yêu cầu một giới hạn khác, hãy đặt giới hạn đó từ điểm vào chính của bạn bằng cách sử dụng mã bất khả tri của phiên bản Python vì các API này đã được thêm vào trong các bản phát hành bản vá bảo mật trong các phiên bản trước 3. 11
Example
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 630
Nếu bạn cần tắt hoàn toàn, hãy đặt thành
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 642
chú thích
Thông tin bổ sung về các phương pháp đặc biệt này có thể được tìm thấy trong Python Reference Manual []
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
Chúng phải có vì trình phân tích cú pháp không thể cho biết loại toán hạng
4[,,,]Các ký tự viết hoa là những ký tự có thuộc tính danh mục chung là một trong số “Lu” [Chữ cái, chữ hoa], “Ll” [Chữ cái, chữ thường] hoặc “Lt” [Chữ cái, chữ hoa tiêu đề]
5[,]Do đó, để chỉ định dạng một bộ dữ liệu, bạn nên cung cấp một bộ dữ liệu đơn có phần tử duy nhất là bộ dữ liệu được định dạng