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, ________ 049, ________ 050, ________ 051, ________ 052
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, do đó,def bit_length[self]: 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
Không thể tùy chỉnh hành vi của toán tử và;
Hai thao tác khác 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
def bit_length[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
Các loại số — , ,
Có ba loại số riêng biệt. số nguyên, số dấu phẩy động và số phức. Ngoài ra, Booleans là một kiểu con của số nguyên. Số nguyên có độ chính xác không giới hạn. Số dấu phẩy động thường được triển khai bằng cách sử dụng double trong C; . Số phức có phần thực và phần ảo, mỗi phần là một số dấu chấm động. Để trích xuất các phần này từ một số phức z, hãy sử dụng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6105 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'] --> 6106. [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
def bit_length[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 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'] --> 6110 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 để có đượ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 toán tử số học nhị phân có toán hạng thuộc các loại số khác nhau, 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 đủ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6114
tổng của x và y
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6115
sự khác biệt của x và y
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6116
sản phẩm của x và y
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6117
thương của x và y
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6118
thương số sàn của x và y
[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'] --> 6119
phần còn lại 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'] --> 6117
[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'] --> 6121
x phủ đị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'] --> 6122
x không thay đổ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'] --> 6123
giá trị tuyệt đối hoặc độ lớn của x
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6125
x chuyển thành số nguyên
[3][6]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6127
x được chuyển đổi thành dấu phẩy động
[4][6]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6129
số phức có phần thực là phần ảo. tôi mặc định là không
[6]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6131
liên hợp của số phức c
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6132
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'] --> 6133
[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'] --> 6135
x lũy thừa y
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6137
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.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
138 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
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
140 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
141,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
142 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
141 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
144 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
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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
149 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
150 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 đế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
153 hoặc bất kỳ mã Unicode tương đương nào [điểm mã với thuộc tínhdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
154]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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
154
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ú
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6171
bitwise hoặc của x và y
[4]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6172
loại trừ theo bit hoặc của x và y
[4]
def bit_length[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
bitwise và của x và y
[4]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6174
x dịch sang trái n bit
[1][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'] --> 6175
x dịch sang phải n bit
[1][3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6176
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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
178Dịch chuyển sang phải n bit tương đương với phép chia tầng cho
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
178Thực hiện các tính toán này với ít nhất một bit mở rộng dấu phụ trong biểu diễn phần bù của hai hữu hạn [độ rộng bit làm việc là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
180 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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 601
Chính xác hơn, 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'] --> 6182 khác 0, 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'] --> 6183 là số nguyên dương duy 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'] --> 6184 sao 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'] --> 6185. Tương tự, khi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6123 đủ nhỏ để có logarit được làm tròn chính xác, 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'] --> 6187. 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'] --> 6182 bằng 0, 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'] --> 6183 trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 642
Tương đương với
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
Mới trong phiên bản 3. 1
int. bit_count[]Trả về số đơn vị trong biểu diễn nhị phân của giá trị tuyệt đối của số nguyên. Đây còn được gọi là số lượng dân số. Ví dụ
def bit_length[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
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'] --> 613
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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 614
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à
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6192. Nếu thứ tự byte 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'] --> 6192, thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu thứ tự byte 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'] --> 6194, 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 đã 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, một số sẽ tă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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 620
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'] --> 621
Mới trong phiên bản 3. 2
Đã thay đổi trong phiên bản 3. 11. Đã thêm giá trị đối số mặc định 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'] --> 6199 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'] --> 61300. 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
def bit_length[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
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à
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6192. Nếu thứ tự byte 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'] --> 6192, thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu thứ tự byte 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'] --> 6194, 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 bit_length[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
Mới trong phiên bản 3. 2
Đã thay đổi trong phiên bản 3. 11. Đã thêm giá trị đối số mặc định 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'] --> 61300. int. as_integer_ratio[]
Trả về một cặp số nguyên có tỷ lệ chính xác bằng số nguyên ban đầu và có mẫu số dương. Tỷ lệ nguyên của các số nguyên [số nguyên] luôn là số nguyên làm tử số 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 làm mẫu số
Mới trong phiên bản 3. 8
Phương pháp bổ sung trên Float
Kiểu float thực hiện. float cũng có các phương thức bổ sung sau
nổi. as_integer_ratio[]Trả về một cặp số nguyên có tỷ lệ chính xác bằng số float ban đầu và có mẫu số dương. Tăng trên vô số và trên NaN
nổi. is_integer[]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 đối tượng float là hữu hạn với giá trị nguyên và ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638
def bit_length[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
Hai phương pháp hỗ trợ chuyển đổi sang và từ các chuỗi thập lục phân. Vì số float của Python được lưu trữ bên trong dưới dạng số nhị phân, nên việc chuyển đổi số float thành hoặc từ chuỗi thập phân thường liên quan đến một lỗi làm tròn nhỏ. Ngược lại, các chuỗi thập lục phân cho phép biểu diễn và đặc tả chính xác các số dấu phẩy động. Điều này có thể hữu ích khi gỡ lỗi và trong công việc số
nổi. hex[]Trả về biểu diễn của số dấu phẩy động dưới dạng chuỗi thập lục phân. Đối với các số dấu phẩy động hữu hạn, cách biểu diễn này sẽ luôn bao gồm 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'] --> 61312 ở đầu và 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'] --> 61313 ở cuối và số mũphương thức lớp phao. từ hex[s]
Phương thức lớp để trả về số float được biểu thị bằng chuỗi thập lục phân s. Chuỗi s có thể có khoảng trắng ở đầu và cuối
Lưu ý rằng đó là một phương thức cá thể, trong khi đó là một phương thức lớp
Một chuỗi thập lục phân có dạng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 60
trong đó tùy chọn
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61316 có thể bằng một trong hai
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6169 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'] --> 6170,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61319 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'] --> 61320 là chuỗi các chữ số thập lục phân 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'] --> 61321 là số nguyên thập phân có dấu tùy chọn ở đầu. Trường hợp không đáng kể và phải có ít nhất một chữ số thập lục phân trong số nguyên hoặc phân số. Cú pháp này tương tự như cú pháp quy định tại mục 6. 4. 4. 2 của tiêu chuẩn C99 và cả cú pháp được sử dụng trong Java 1. 5 trở đi. Cụ thể, đầu ra của có thể sử dụng dưới dạng ký tự dấu phẩy động thập lục phân trong mã C hoặc Java và các chuỗi thập lục phân được tạo bởi ký tự định dạng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61323 của C 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'] --> 61324 của Java được chấp nhận bởi
Lưu ý rằng số mũ được viết dưới dạng thập phân chứ không phải thập lục phân và nó mang lại sức mạnh của 2 để nhân hệ số. Ví dụ: chuỗi thập lục phân
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61326 đại diện cho số dấu phẩy động
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61327 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'] --> 61328
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61
Áp dụng chuyển đổi ngược lại cho
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61328 sẽ cho một chuỗi thập lục phân khác đại diện cho cùng một số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62
Băm các loại số
Đối với các số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6182 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'] --> 61331, có thể thuộc các loại khác nhau, yêu cầu là ____11332 bất cứ khi nào ____11333 [xem tài liệu về phương pháp để biết thêm chi tiết]. Để dễ triển khai và hiệu quả trên nhiều loại số [bao gồm , và ] Hàm băm của Python cho các loại số dựa trên một hàm toán học duy nhất được xác định cho bất kỳ số hữu tỷ nào và do đó áp dụng cho tất cả các trường hợp của và , và tất cả các trường hợp hữu hạn . Về cơ bản, chức năng này được đưa ra bởi giảm modulo
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61343 cho một số nguyên tố 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'] --> 61343. Giá trị 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'] --> 61343 được cung cấp cho Python dưới dạng 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'] --> 61346 của
Chi tiết triển khai CPython. Hiện tại, số nguyên tố được sử dụng 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'] --> 61348 trên các máy có độ dài C 32 bit 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'] --> 61349 trên các máy có độ dài C 64 bit
Dưới đây là các quy tắc chi tiết
Nếu
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1350 là một số hữu tỉ không âm 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
1351 không chia hết chodef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1343, hãy định nghĩ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
1353 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
1354, trong đódef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1355 cho số nghịch đảo 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
1351 theo modulodef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1343Nế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
1350 là một số hữu tỉ không âm 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
1351 chia hết chodef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1343 [như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
1361 thì không] thìdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1351 không có modulo nghịch đảodef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1343 và quy tắc trên không áp dụng;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
1350 là một số hữu tỷ âm, xác địnhdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1353 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
1368. Nếu kết quả băm 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
141, hãy thay thế nó 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
1370Các giá trị cụ thể
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1365 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
1372 được sử dụng làm giá trị băm cho vô cực dương hoặc vô cực âm [tương ứng]Đối với một số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1374, giá trị băm của phần thực và phần ảo được kết hợp bằng cách tính toándef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1375, rút gọn modulodef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1376 để nó nằm trongdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1377. Một lần nữa, nếu kết quả là ________ 5141, nó sẽ được thay thế bằng ________ 11370
Để làm rõ các quy tắc trên, đây là một số mã Python ví dụ, tương đương với hàm băm tích hợp, để tính toán hàm băm của một số hữu tỷ, hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63
Các loại trình lặp
Python hỗ trợ khái niệm lặp qua các vùng chứa. Điều này được thực hiện bằng hai phương pháp riêng biệt; . Các trình tự, được mô tả chi tiết hơn bên dưới, luôn hỗ trợ các phương pháp lặp
Một phương thức cần được xác định cho các đối tượng vùng chứa để cung cấp hỗ trợ
vùng chứa. __iter__[]Trả lại một đối tượng. Đối tượng được yêu cầu hỗ trợ giao thức iterator được mô tả bên dưới. Nếu một vùng chứa hỗ trợ các kiểu lặp khác nhau, thì có thể cung cấp các phương thức bổ sung để yêu cầu cụ thể các trình vòng lặp cho các kiểu lặp đó. [Ví dụ về một đối tượng hỗ trợ nhiều hình thức lặp lại sẽ là một cấu trúc cây hỗ trợ cả truyền tải theo chiều rộng và theo chiều sâu. ] Phương thức này tương ứng với vị trí của cấu trúc kiểu cho các đối tượng Python trong API Python/C
Bản thân các đối tượng lặp được yêu cầu hỗ trợ hai phương thức sau, cùng nhau tạo thành giao thức lặp
trình lặp. __iter__[]Trả lại chính đối tượng. Điều này là bắt buộc để cho phép sử dụng cả bộ chứa và bộ lặp với câu lệnh và. Phương thức này tương ứng với vị trí của cấu trúc kiểu cho các đối tượng Python trong API Python/C
trình lặp. __next__[]Trả lại mục tiếp theo từ. Nếu không có mục nào khác, hãy đưa ra ngoại lệ. Phương thức này tương ứng với vị trí của cấu trúc kiểu cho các đối tượng Python trong API Python/C
Python định nghĩa một số đối tượng trình lặp để hỗ trợ phép lặp qua các loại trình tự chung và cụ thể, từ điển và các dạng chuyên biệt hơn khác. Các loại cụ thể không quan trọng ngoài việc triển khai giao thức lặp
Khi một phương thức của trình vòng lặp tăng lên, nó phải tiếp tục làm như vậy trong các lần gọi tiếp theo. Việc triển khai không tuân theo thuộc tính này được coi là bị hỏng
Các loại máy phát điện
Python cung cấp một cách thuận tiện để triển khai giao thức lặp. Nếu phương thức
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61390 của đối tượng vùng chứa được triển khai dưới dạng trình tạo, thì nó sẽ tự động trả về một đối tượng trình vòng lặp [về mặt kỹ thuật, đối tượng trình tạo] cung 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'] --> 61390 và các phương thức. Thông tin thêm về máy phát điện có thể được tìm thấy trong
Các loại trình tự — , ,
Có ba loại trình tự cơ bản. danh sách, bộ dữ liệu và đối tượng phạm vi. Các loại trình tự bổ sung được điều chỉnh để xử lý và được mô tả trong các phần dành riêng
Hoạt động tuần tự phổ biến
Các hoạt động trong bảng sau được hỗ trợ bởi hầu hết các loại trình tự, cả có thể thay đổi và không thể thay đổi. ABC được cung cấp để giúp triển khai chính xác các thao tác này trên các loại trình tự tùy chỉnh dễ dàng hơn
Bảng này liệt kê các hoạt động trình tự được sắp xếp theo mức độ ưu tiên tăng dần. Trong bảng, s và t là các chuỗi cùng loại, n, i, j và k là các số nguyên và x là một đối tượng tùy ý đáp ứng mọi hạn chế về loại và giá trị do s áp đặt
Các 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'] --> 698 và
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 699 có cùng mức độ ưu tiên như các hoạt động so sánh. Các phép toán
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6169 [nối] 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'] --> 61400 [lặp lại] có cùng mức độ ưu tiên như các phép toán số tương ứng.
Hoạt động
Kết quả
ghi chú
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61401
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu một phần tử của s bằng x, ngược lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638
[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'] --> 61404
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 nếu một phần tử của s bằng x, ngược lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656
[1]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61407
nối của s và t
[6][7]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61408 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'] --> 61409
tương đương với việc thêm s vào chính nó n lần
[2][7]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61410
mục thứ i của s, gốc 0
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61411
lát s từ i đến j
[3][4]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61412
lát s từ i đến j với bước k
[3][5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413
chiều dài của 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'] --> 61414
mục nhỏ nhất của 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'] --> 61415
mục lớn nhất của 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'] --> 61416
chỉ số của lần xuất hiện đầu tiên của x trong s [tại hoặc sau chỉ số i và trước chỉ số j]
[số 8]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61417
tổng số lần xuất hiện của x trong s
Các chuỗi cùng loại cũng hỗ trợ so sánh. Cụ thể, các bộ dữ liệu và danh sách được so sánh theo từ điển bằng cách so sánh các phần tử tương ứng. Điều này có nghĩa là để so sánh bằng nhau, mọi phần tử phải so sánh bằng nhau và hai dãy phải cùng loại và có cùng độ dài. [Để biết đầy đủ chi tiết xem trong tài liệu tham khảo ngôn ngữ. ]
Các trình vòng lặp chuyển tiếp và đảo ngược qua các chuỗi có thể thay đổi truy cập các giá trị bằng chỉ mục. Chỉ số đó sẽ tiếp tục tiến [hoặc lùi] ngay cả khi trình tự cơ bản bị đột biến. Trình vòng lặp chỉ kết thúc khi gặp an hoặc a [hoặc khi chỉ số giảm xuống dưới 0]
ghi chú
Mặc dù các hoạt động
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
98 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
99 chỉ được sử dụng để kiểm tra ngăn chặn đơn giản trong trường hợp chung, nhưng một số trình tự chuyên biệt [chẳng hạn như , và ] cũng sử dụng chúng để kiểm tra trình tự tiếp theodef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
4Các giá trị của n nhỏ hơn
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
42 được coi 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
42 [tạo ra một chuỗi trống cùng loại với s]. Lưu ý rằng các mục trong chuỗi s không được sao chép; . Điều này thường ám ảnh các lập trình viên Python 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'] --> 6
5Điều đã xảy ra 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
1427 là danh sách một phần tử chứa danh sách trống, vì vậy cả ba phần tử 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
1428 đều là tham chiếu đến danh sách trống duy nhất này. Sửa đổi bất kỳ thành phần nào 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
1429 sẽ sửa đổi danh sách duy nhất này. Bạn có thể tạo một danh sách các danh sách khác nhau theo cách nà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
6Giải thích thêm có sẵn trong mục Câu hỏi thường gặp
Nếu i hoặc j âm, chỉ số liên quan đến phần cuối của chuỗi s.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1430 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
1431 được thay thế. Nhưng lưu ý rằ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
1432 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
42Lát của s từ i đến j được định nghĩa là chuỗi các phần tử có chỉ số k sao cho
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1434. Nếu i hoặc j lớn hơn ________ 11413, thì usa ________ 11413. Nếu tôi 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, hãy sử dụ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
42. Nếu 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, hãy sử dụ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
1413. Nếu i lớn hơn hoặc bằng j, lát cắt trốngLát s từ i đến j với bước k được định nghĩa là chuỗi các 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
1441 sao chodef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1442. Nói cách khác, các chỉ số 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
1443,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1444,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1445,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1446, v.v., dừng khi đạt đến j [nhưng không bao giờ bao gồm j]. Khi k dương, i và j bị giảm xuố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
1413 nếu chúng lớn hơn. Khi k âm, i và j bị giảm xuố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
1448 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]. Lưu ý, k không thể bằng 0. Nếu 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'] --> 6
31, nó được coi 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
55Nối các chuỗi bất biến luôn dẫn đến một đối tượng mới. Điều này có nghĩa là việc xây dựng một chuỗi bằng cách nối lặp lại sẽ có chi phí thời gian chạy bậc hai trong tổng chiều dài chuỗi. Để có chi phí thời gian chạy tuyến tính, bạn phải chuyển sang một trong các lựa chọn thay thế bên dưới
nếu nối các đối tượng, bạn có thể tạo một danh sách và sử dụng ở cuối hoặc nếu không thì ghi vào một thể hiện và truy xuất giá trị của nó khi hoàn tất
nếu nối các đối tượng, bạn có thể sử dụng tương tự hoặc hoặc bạn có thể thực hiện nối tại chỗ với một đối tượng. các đối tượng có thể thay đổi và có cơ chế phân bổ tổng thể hiệu quả
nếu nối các đối tượng, thay vào đó hãy mở rộng a
đối với các loại khác, hãy điều tra tài liệu lớp có liên quan
Một số loại trình tự [chẳng hạn như ] chỉ hỗ trợ các trình tự vật phẩm tuân theo các mẫu cụ thể và do đó không hỗ trợ nối hoặc lặp lại trì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
1463 tăng khi không tìm thấy x trong s. Không phải tất cả các triển khai đều hỗ trợ chuyển các đối số bổ sung i và j. Các đối số này cho phép tìm kiếm hiệu quả các phần phụ của chuỗi. Việc truyền các đối số bổ sung gần tương đương với việc sử dụ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
1465, chỉ là không sao chép bất kỳ dữ liệu nào và với chỉ mục được trả về có liên quan đến phần đầu của chuỗi chứ không phải phần đầu của lát cắt
Các loại trình tự bất biến
Thao tác duy nhất mà các loại trình tự bất biến thường triển khai mà các loại trình tự có thể thay đổi cũng không thực hiện được là hỗ trợ cho trình tự tích hợp sẵn
Hỗ trợ này cho phép các chuỗi bất biến, chẳng hạn như phiên bản, được sử dụng làm khóa và được lưu trữ trong và phiên bản
Cố gắng băm một chuỗi bất biến có chứa các giá trị không thể băm được sẽ dẫn đến
Các loại trình tự có thể thay đổi
Các hoạt động trong bảng sau được xác định trên các loại trình tự có thể thay đổi. ABC được cung cấp để giúp triển khai chính xác các thao tác này trên các loại trình tự tùy chỉnh dễ dàng hơn
Trong bảng s là một thể hiện của loại trình tự có thể thay đổi, t là bất kỳ đối tượng có thể lặp lại nào và x là một đối tượng tùy ý đáp ứng mọi hạn chế về loại và giá trị do s áp đặt [ví dụ: chỉ chấp nhận các số nguyên đáp ứng hạn chế về 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'] --> 61474]
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'] --> 61475
mục i của s được thay thế bằng x
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61476
lát s từ i đến j được thay thế bằng nội dung của iterable 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'] --> 61477
giống 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'] --> 61478
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61479
các phần 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'] --> 61412 được thay thế bằng các phần tử của t
[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'] --> 61481
xóa các phần 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'] --> 61412 khỏi danh sách
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61483
nối x vào cuối dãy [giống 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'] --> 61484]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61485
xóa tất cả các mục khỏi s [giống 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'] --> 61486]
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61487
tạo một bản sao nông của s [giống 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'] --> 61488]
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61489 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'] --> 61490
kéo dài s với nội dung của t [phần lớn giống 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'] --> 61491]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61492
cập nhật s với nội dung được lặp lại n lần
[6]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61493
chèn x vào s tại chỉ mục được cung cấp bởi i [giống 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'] --> 61494]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61495 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'] --> 61496
truy xuất mục tại i và cũng xóa mục đó khỏi s
[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'] --> 61497
xóa mục đầu tiên khỏi s 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'] --> 61410 bằng x
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61499
đảo ngược các mục của s tại chỗ
[4]
ghi chú
t phải có cùng độ dài với lát cắt mà nó đang thay thế
Đối số tùy chọn i mặc định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
141, do đó, theo mặc định, mục cuối cùng được xóa và trả vềdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2001 tăng khi không tìm thấy x trong sPhương pháp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2003 sửa đổi trình tự tại chỗ để tiết kiệm không gian khi đảo ngược một trình tự lớn. Để nhắc nhở người dùng rằng nó hoạt động theo tác dụng phụ, nó không trả về trình tự đảo ngượ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
2004 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
2005 được bao gồm để thống nhất với giao diện của các vùng chứa có thể thay đổi không hỗ trợ thao tác cắt [chẳng hạn như và ].def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2005 không phải là một phần của ABC, nhưng hầu hết các lớp trình tự có thể thay đổi cụ thể đều cung cấp nóMới trong phiên bản 3. 3. ______12004 và phương thức
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2005.Giá trị n là một số nguyên hoặc một đối tượng thực hiện. Giá trị 0 và âm của n xóa chuỗi. Các mục trong chuỗi không được sao chép;
danh sách
Danh sách là các chuỗi có thể thay đổi, thường được sử dụng để lưu trữ các bộ sưu tập các mục đồng nhất [trong đó mức độ tương tự chính xác sẽ thay đổi tùy theo ứng dụng]
lớp danh sách[[có thể lặp lại]]Danh sách có thể được xây dựng theo nhiều cách
Sử dụng một cặp dấu ngoặc vuông để biểu thị danh sách 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
49Sử dụng dấu ngoặc vuông, phân tách các mục bằng dấu phẩy.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2015,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2016Sử dụng hiểu danh sách.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2017Sử 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
2018 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
2019
Hàm tạo xây dựng một danh sách có các mục giống nhau và theo cùng thứ tự với các mục của iterable. iterable có thể là một chuỗi, một vùng chứa hỗ trợ phép lặp hoặc một đối tượng lặp. Nếu iterable đã là một danh sách, một bản sao sẽ được tạo và trả lại, tương 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'] --> 62020. 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'] --> 62021 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'] --> 62022 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'] --> 62023 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'] --> 62024. Nếu không có đối số nào được đưa ra, hàm tạo sẽ tạo một danh sách 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'] --> 649
Nhiều thao tác khác cũng tạo ra các danh sách, bao gồm cả danh sách tích hợp sẵn
Danh sách thực hiện tất cả các hoạt động và trình tự. Danh sách cũng cung cấp phương pháp bổ sung sau
sắp xếp[* , phím=None, reverse=False]Phương pháp này sắp xếp danh sách tại chỗ, chỉ sử dụng 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'] --> 674 giữa các mục. Các ngoại lệ không bị chặn - nếu bất kỳ thao tác so sánh nào không thành công, toàn bộ thao tác sắp xếp sẽ không thành công [và danh sách có thể sẽ ở trạng thái được sửa đổi một phần]
chấp nhận hai đối số chỉ có thể được chuyển bởi từ khóa []
khóa chỉ định chức năng của một đối số được sử dụng để trích xuất khóa so sánh từ mỗi thành phần danh sách [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'] --> 62029]. Khóa tương ứng với mỗi mục trong danh sách được tính một lần và sau đó được sử dụng cho toàn bộ quá trình sắp xếp. Giá trị mặc định 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'] --> 631 có nghĩa là các mục trong danh sách được sắp xếp trực tiếp mà không cần tính giá trị khóa riêng
Tiện ích có sẵn để chuyển đổi 2. x style cmp chức năng thành một chức năng chính
đảo ngược là một giá trị boolean. Nếu được đặ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'] --> 656, thì các thành phần danh sách được sắp xếp như thể mỗi phép so sánh được đảo ngược
Phương pháp này sửa đổi trình tự tại chỗ để tiết kiệm không gian khi sắp xếp một trình tự lớn. Để nhắc nhở người dùng rằng nó hoạt động theo tác dụng phụ, nó không trả về chuỗi đã sắp xếp [sử dụng để yêu cầu rõ ràng một thể hiện danh sách được sắp xếp mới]
Phương pháp được đảm bảo ổn định. Một sắp xếp ổn định nếu nó đảm bảo không thay đổi thứ tự tương đối của các phần tử được so sánh bằng nhau — điều này hữu ích cho việc sắp xếp theo nhiều lần [ví dụ: sắp xếp theo bộ phận, sau đó theo bậc lương]
Để biết các ví dụ sắp xếp và hướng dẫn sắp xếp ngắn gọn, hãy xem
Chi tiết triển khai CPython. Trong khi danh sách đang được sắp xếp, tác động của việc cố gắng thay đổi hoặc thậm chí kiểm tra, danh sách không được xác định. Việc triển khai C của Python làm cho danh sách xuất hiện trống trong suốt thời gian và tăng lên nếu nó có thể phát hiện ra rằng danh sách đã bị thay đổi trong quá trình sắp xếp
bộ dữ liệu
Các bộ dữ liệu là các chuỗi bất biến, thường được sử dụng để lưu trữ các bộ sưu tập dữ liệu không đồng nhất [chẳng hạn như 2 bộ dữ liệu được tạo bởi bộ tích hợp]. Các bộ dữ liệu cũng được sử dụng cho các trường hợp cần một chuỗi dữ liệu đồng nhất bất biến [chẳng hạn như cho phép lưu trữ trong một hoặc một thể hiện]
lớp bộ[[có thể lặp lại]]Tuples có thể được xây dựng trong một số cách
Sử dụng một cặp dấu ngoặc đơn để biểu thị bộ dữ liệu 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
48Sử dụng dấu phẩy ở cuối cho một tuple đơ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
2040 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
2041Tách các mục bằng dấu phẩy.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2042 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
2043Sử dụng tích hợp.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2044 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
2046
Hàm tạo xây dựng một bộ có các mục giống nhau và theo cùng thứ tự như các mục của iterable. iterable có thể là một chuỗi, một vùng chứa hỗ trợ phép lặp hoặc một đối tượng lặp. Nếu iterable đã là một Tuple, nó sẽ được trả về không thay đổi. 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'] --> 62047 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'] --> 62048 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'] --> 62049 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'] --> 62050. 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
Lưu ý rằng thực ra dấu phẩy tạo nên một bộ chứ không phải dấu ngoặc đơn. Các dấu ngoặc đơn là tùy chọn, ngoại trừ trong trường hợp bộ dữ liệu trống hoặc khi cần thiết để tránh sự mơ hồ về cú pháp. 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'] --> 62052 là một lệnh gọi hàm có ba đối số, trong khi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62053 là một lệnh gọi hàm có 3 bộ làm đối số duy nhất
Tuples thực hiện tất cả các hoạt động trình tự
Đối với các bộ sưu tập dữ liệu không đồng nhất trong đó truy cập theo tên rõ ràng hơn truy cập theo chỉ mục, có thể là lựa chọn phù hợp hơn so với đối tượng tuple đơn giản
Các dãy
Loại đại diện cho một dãy số bất biến và thường được sử dụng để lặp một số lần cụ thể trong các vòng lặp
lớp phạm vi[dừng]class range[start, stop[, step]]Các đối số cho hàm tạo phạm vi phải là số nguyên [tích hợp sẵn hoặc bất kỳ đối tượng nào triển khai phương thức đặc biệt]. Nếu đối số bước bị bỏ qua, nó sẽ mặc định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 655. Nếu đối số bắt đầu bị bỏ qua, nó sẽ mặc định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 642. Nếu bước bằng 0, được nâng lên
Đối với một bước tích cực, nội dung của một phạm vi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62062 được xác định theo cô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'] --> 62063 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'] --> 62064 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'] --> 62065
Đối với bước phủ định, nội dung của phạm vi vẫn được xác định theo cô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'] --> 62063, nhưng các ràng buộ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'] --> 62064 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'] --> 62068
Một đối tượng phạm vi sẽ trống 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'] --> 62069 không đáp ứng ràng buộc giá trị. 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
Phạm vi chứa giá trị tuyệt đối lớn hơn giá trị cho phép nhưng một số tính năng [chẳng hạn như ] có thể tăng
Ví dụ phạm vi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 67
Phạm vi thực hiện tất cả các thao tác trình tự ngoại trừ phép nối và phép lặp [do thực tế là các đối tượng phạm vi chỉ có thể biểu diễn các trình tự tuân theo một mẫu nghiêm ngặt và phép lặp và phép nối thường sẽ vi phạm mẫu đó]
bắt đầuGiá trị của tham số bắt đầ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'] --> 642 nếu tham số không được cung cấp]dừng lại
Giá trị của tham số dừng
bước chânGiá trị của tham số bước [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'] --> 655 nếu tham số không được cung cấp]
Ưu điểm của loại so với thông thường hoặc đối tượng sẽ luôn chiếm cùng một lượng bộ nhớ [nhỏ], bất kể kích thước của phạm vi mà nó đại diện [vì nó chỉ lưu trữ các 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'] --> 62079,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62080 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'] --> 62081, tính toán các mục riêng lẻ
Các đối tượng phạm vi triển khai ABC và cung cấp các tính năng như kiểm tra ngăn chặn, tra cứu chỉ mục phần tử, cắt lát và hỗ trợ cho các chỉ số âm [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'] --> 68
Kiểm tra các đối tượng phạm vi cho bình đẳ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'] --> 678 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'] --> 679 so sánh chúng như trình tự. Nghĩa là, hai đối tượng phạm vi được coi là bằng nhau nếu chúng đại diện cho cùng một chuỗi giá trị. [Lưu ý rằng hai đối tượng phạm vi so sánh bằng nhau có thể có các thuộc tính và khác nhau, 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'] --> 62088 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'] --> 62089. ]
Đã thay đổi trong phiên bản 3. 2. Triển khai Trình tự ABC. Hỗ trợ cắt lát và chỉ số âm. Kiểm tra các đối tượng để trở thành thành viên trong thời gian không đổi thay vì lặp qua tất cả các mục.
Đã thay đổi trong phiên bản 3. 3. Xác định ‘==’ và ‘. =’ để so sánh các đối tượng phạm vi dựa trên chuỗi giá trị mà chúng xác định [thay vì so sánh dựa trên danh tính đối tượng].
Mới trong phiên bản 3. 3. Các thuộc tính , và.
Xem thêm
Công thức linspace cho thấy cách triển khai phiên bản phạm vi lười biếng phù hợp với các ứng dụng dấu phẩy động
Loại chuỗi văn bản —
Dữ liệu văn bản trong Python được xử lý bằng các đối tượng hoặc chuỗi. Các chuỗi là bất biến của các điểm mã Unicode. Chuỗi ký tự được viết theo nhiều cách khác nhau
Dấu nháy đơ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
2096Dấu ngoặc ké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
2097Ba trích dẫ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
2098,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2099
Các chuỗi được trích dẫn ba lần có thể kéo dài trên nhiều dòng - tất cả khoảng trắng được liên kết sẽ được bao gồm trong chuỗi ký tự
Các chuỗi ký tự là một phần của một biểu thức và chỉ có khoảng trắng giữa chúng sẽ được chuyển đổi hoàn toàn thành một chuỗi ký tự đơn. Đó 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'] --> 62100
Xem để biết thêm về các dạng chuỗi ký tự khác nhau, bao gồm các chuỗi thoát được hỗ trợ và tiề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'] --> 62062 [“raw”] vô hiệu hóa hầu hết quá trình xử lý chuỗi thoát
Các chuỗi cũng có thể được tạo từ các đối tượng khác bằng cách sử dụng hàm tạo
Vì không có loại "ký tự" riêng biệt, nên việc lập chỉ mục một chuỗi sẽ tạo ra các chuỗi có độ dài 1. Nghĩa là, đối với một chuỗi không trố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'] --> 62103
Cũng không có loại chuỗi có thể thay đổi, nhưng hoặc có thể được sử dụng để xây dựng chuỗi từ nhiều đoạn một cách hiệu quả
Đã thay đổi trong phiên bản 3. 3. Để tương thích ngược với chuỗi Python 2, tiề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'] --> 62106 một lần nữa được cho phép trên chuỗi ký tự. Nó không ảnh hưởng đến ý nghĩa của chuỗi ký tự và không thể kết hợp với tiề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'] --> 62062. lớp str[đối tượng='']class str[object=b'', encoding='utf-8', errors='strict']
Trả về một phiên bản của đối tượng. Nếu đối tượng không được cung cấp, trả về chuỗi rỗng. Mặt khác, hành vi 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'] --> 633 phụ thuộc vào việc mã hóa hoặc lỗi được cung cấp hay không, như sau
Nếu không đưa ra mã hóa cũng như 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'] --> 62109 trả về , đây là biểu diễn chuỗi đối tượng "không chính thức" hoặc có thể in được. Đối với các đối tượng chuỗi, đây chính là chuỗi. Nếu đối tượng không có phương thức, thì quay lại quay lại
Nếu ít nhất một mã hóa hoặc lỗi được đưa ra, đối tượng phải là một [e. g. hoặc ]. Trong trường hợp này, nếu đối tượng là một [hoặc ] đối tượng, 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'] --> 62118 tương đương với. Mặt khác, đối tượng byte bên dưới đối tượng bộ đệm được lấy trước khi gọi. Xem và để biết thông tin về các đối tượng đệm
Truyền một đối tượng mà không có các đối số mã hóa hoặc lỗi thuộc trường hợp đầu tiên trả về biểu diễn chuỗi không chính thức [xem thêm tùy chọn dòng lệnh cho Python]. 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'] --> 69
Để biết thêm thông tin về lớ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'] --> 61422 và các phương thức của nó, hãy xem và phần bên dưới. Để xuất các chuỗi có định dạng, hãy xem phần và. Ngoài ra, xem phần
Phương thức chuỗi
Các chuỗi triển khai tất cả các thao tác trình tự, cùng với các phương thức bổ sung được mô tả bên dưới
Chuỗi cũng hỗ trợ hai kiểu định dạng chuỗi, một cung cấp mức độ linh hoạt và tùy chỉnh lớn [xem và ] và kiểu kia dựa trên định dạng kiểu 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'] --> 62126 xử lý phạm vi loại hẹp hơn và khó sử dụng chính xác hơn một chút, nhưng thường là
Phần của thư viện chuẩn bao gồm một số mô-đun khác cung cấp nhiều tiện ích liên quan đến văn bản [bao gồm hỗ trợ biểu thức chính quy trong mô-đun]
str. viết hoa[]Trả về một bản sao của chuỗi với ký tự đầu tiên được viết hoa và phần còn lại được viết thường
Đã thay đổi trong phiên bản 3. 8. Ký tự đầu tiên hiện được đặt thành chữ hoa tiêu đề thay vì chữ hoa. Điều này có nghĩa là các ký tự như chữ ghép sẽ chỉ viết hoa chữ cái đầu tiên, thay vì ký tự đầy đủ.
str. casefold[]Trả về một bản sao của chuỗi. Chuỗi casefolded có thể được sử dụng để khớp không caseless
Casefolding tương tự như chữ thường nhưng tích cực hơn vì nó nhằm mục đích loại bỏ tất cả các phân biệt chữ hoa chữ thường trong một chuỗi. Ví dụ: chữ thường tiế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'] --> 62128 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'] --> 62129. Vì nó đã là chữ thường, nên sẽ không làm gì 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'] --> 62128;
Thuật toán casefolding được mô tả trong phần 3. 13 của Tiêu chuẩn Unicode
Mới trong phiên bản 3. 3
str. trung tâm[chiều rộng[ , fillchar]]Trả về căn giữa trong một chuỗi có chiều dài chiều rộng. Việc đệm được thực hiện bằng cách sử dụng ký tự điền được chỉ định [mặc định là không gian ASCII]. Chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413str. đếm[phụ[ , start[, end]]]
Trả về số lần xuất hiện không trùng lặp của chuỗi con sub trong phạm vi [bắt đầu, kết thúc]. Các đối số tùy chọn bắt đầu và kết thúc được diễn giải như trong ký hiệu lát cắt
Nếu phụ trống, trả về số lượng chuỗi trống giữa các ký tự bằng độ dài của chuỗi cộng với một
str. mã hóa[mã hóa=', errors='strict']Trả lại chuỗi được mã hóa thành
mã hóa mặc định 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'] --> 62136;
lỗi kiểm soát cách xử lý lỗi mã hóa. 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'] --> 62137 [mặc định], một ngoại lệ được đưa ra. Các giá trị có thể khá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'] --> 62139,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62140,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62141,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62142 và bất kỳ tên nào khác được đăng ký qua. Xem để biết chi tiết
Vì lý do hiệu suất, giá trị của lỗi không được kiểm tra tính hợp lệ trừ khi thực sự xảy ra lỗi mã hóa, được bật hoặc a được sử dụng
Đã thay đổi trong phiên bản 3. 1. Đã thêm hỗ trợ cho đối số từ khóa.
Đã thay đổi trong phiên bản 3. 9. Giá trị của đối số lỗi hiện được kiểm tra trong và trong.
str. endswith[hậu tố[ , start[, end]]]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu chuỗi kết thúc bằng hậu tố đã chỉ định, nếu không thì trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. hậu tố cũng có thể là một bộ hậu tố cần tìm. Với bắt đầu tùy chọn, bắt đầu kiểm tra tại vị trí đó. Với đầu cuối tùy chọn, dừng so sánh tại vị trí đóstr. tab mở rộng[kích thước tab=8]
Trả về một bản sao của chuỗi trong đó tất cả các ký tự tab được thay thế bằng một hoặc nhiều dấu cách, tùy thuộc vào cột hiện tại và kích thước tab đã cho. Vị trí tab xảy ra với mọi ký tự kích thước tab [mặc định là 8, cho vị trí tab ở các cột 0, 8, 16, v.v.]. Để mở rộng chuỗi, cột hiện tại được đặt thành 0 và chuỗi được kiểm tra từng ký tự. Nếu ký tự là một tab [
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62146], một hoặc nhiều ký tự khoảng trắng sẽ được chèn vào kết quả cho đến khi cột hiện tại bằng với vị trí tab tiếp theo. [Bản thân ký tự tab không được sao chép. ] Nếu ký tự là một dò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'] --> 62147] hoặ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'] --> 62148], nó sẽ được sao chép và cột hiện tại được đặt lại về 0. Bất kỳ ký tự 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ể ký tự đó được thể hiện như thế nào khi in
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 610str. tìm[phụ[ , start[, end]]]
Trả về chỉ số thấp nhất trong chuỗi nơi tìm thấy chuỗi con sub trong lát cắ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'] --> 62149. Các đối số tùy chọn bắt đầu và kết thúc được diễn giải như trong ký hiệu lát cắt. Trả lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6141 nếu không tìm thấy sub
Ghi chú
Phương pháp này chỉ nên được sử dụng nếu bạn cần biết vị trí của phụ. Để kiểm tra sub có phải là xâu con hay không ta dùng 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'] --> 611str. định dạng[*args , **kwargs]
Thực hiện thao tác định dạng chuỗi. Chuỗi mà phương thức này được gọi có thể chứa văn bản bằng chữ hoặc các trường thay thế được phân tách bằng 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'] --> 650. Mỗi trường thay thế chứa chỉ mục số của đối số vị trí hoặc tên của đối số từ khóa. Trả về một bản sao của chuỗi trong đó mỗi trường thay thế được thay thế bằng giá trị chuỗi của đối số tương ứng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 612
Xem mô tả về các tùy chọn định dạng khác nhau có thể được chỉ định trong chuỗi định dạng
Ghi chú
Khi định dạng một số [, , và các lớp con] với 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'] --> 61351 [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'] --> 62159], hàm tạm thời đặt ngôn 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'] --> 62160 thành ngôn 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'] --> 62161 để giải mã các 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'] --> 62162 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'] --> 62163 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'] --> 62164 nếu chúng không phải ASCII hoặc dài hơn 1 byte và ngôn 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'] --> 62161 khác với ngôn 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'] --> 62160. Thay đổi tạm thời này ảnh hưởng đến các chủ đề khác
Đã thay đổi trong phiên bản 3. 7. Khi định dạng một số với 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'] --> 61351, hàm sẽ tạm thời đặt ngôn 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'] --> 62160 thành ngôn 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'] --> 62161 trong một số trường hợp. str. format_map[ánh xạ]
Tương 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'] --> 62170, ngoại trừ việ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'] --> 62171 được sử dụng trực tiếp và không được sao chép vào một. Điều này hữu ích nếu 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'] --> 62171 là một lớp con dict
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 613
Mới trong phiên bản 3. 2
str. chỉ mục[phụ[ , start[, end]]]Thích , nhưng tăng khi không tìm thấy chuỗi con
str. isalnum[]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự trong chuỗi là chữ và số và có ít nhất một ký tự, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Một ký tự
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62178 là chữ và số nếu một trong các giá trị sau trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62180,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62181,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62182 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'] --> 62183str. isalpha[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự trong chuỗi là chữ cái và có ít nhất một ký tự, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Các ký tự chữ cái là những ký tự được định nghĩa trong cơ sở dữ liệu ký tự Unicode là “Chữ cái”, tôi. e. , những người có thuộc tính danh mục chung là một trong số “Lm”, “Lt”, “Lu”, “Ll”, hoặc “Lo”. Lưu ý rằng thuộc tính này khác với thuộc tính “Alphabetic” được xác định trong Tiêu chuẩn Unicodestr. isascii[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu chuỗi trống hoặc tất cả các ký tự trong chuỗi là ASCII, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Các ký tự ASCII có các điểm mã trong phạm vi U+0000-U+007F
Mới trong phiên bản 3. 7
str. hệ thập phân[]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự trong chuỗi là ký tự thập phân và có ít nhất một ký tự, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Các ký tự thập phân là những ký tự có thể được sử dụng để tạo thành các số trong cơ số 10, e. g. U+0660, CHỮ SỐ Ả Rập-INDIC. Chính thức, một ký tự thập phân là một ký tự trong Danh mục chung Unicode “Nd”str. isdigit[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự trong chuỗi là chữ số và có ít nhất một ký tự, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Chữ số bao gồm các ký tự thập phân và chữ số cần xử lý đặc biệt, chẳng hạn như chữ số chỉ số trên tương thích. Điều này bao gồm các chữ số không thể được sử dụng để tạo thành số trong cơ số 10, như số Kharosthi. Chính thức, một chữ số là một ký tự có giá trị thuộc tính Numeric_Type=Digit hoặc Numeric_Type=Decimalstr. mã định danh[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu chuỗi là một mã định danh hợp lệ theo định nghĩa ngôn ngữ, phần
Gọi để kiểm tra xem chuỗ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'] --> 62194 có phải là mã định danh dành riêng hay không, chẳng hạn như và
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'] --> 614str. giảm tốc[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự viết hoa trong chuỗi là chữ thường và có ít nhất một ký tự viết hoa, 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'] --> 638str. số[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự trong chuỗi là ký tự số và có ít nhất một ký tự, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Các ký tự số bao gồm các ký tự chữ số và tất cả các ký tự có thuộc tính giá trị số Unicode, e. g. U+2155, PHÂN SỐ Thô tục MỘT PHẦN NĂM. Về hình thức, các ký tự số là những ký tự có giá trị thuộc tính Numeric_Type=Digit, Numeric_Type=Decimal hoặc Numeric_Type=Numericstr. có thể in được[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự trong chuỗi có thể in được hoặc chuỗi trống, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. Các ký tự không in được là những ký tự được định nghĩa trong cơ sở dữ liệu ký tự Unicode là “Khác” hoặc “Dấu phân cách”, ngoại trừ khoảng trống ASCII [0x20] được coi là có thể in được. [Lưu ý rằng các ký tự có thể in được trong ngữ cảnh này là những ký tự không được thoát khi được gọi trên một chuỗi. Nó không liên quan đến việc xử lý các chuỗi được ghi vào hoặc. ]str. không gian[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu chỉ có ký tự khoảng trắng trong chuỗi và có ít nhất một ký tự, ngược lại là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638
Một ký tự là khoảng trắng nếu trong cơ sở dữ liệu ký tự Unicode [xem phần ], danh mục chung của 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'] --> 62409 [“Dấu phân cách, dấu cách”] hoặc lớp hai chiều của nó là một trong 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'] --> 62410,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62411 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'] --> 62412str. 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à chuỗi có tiêu đề và có ít nhất một ký tự, ví dụ: ký tự hoa chỉ có thể theo sau ký tự không có ký tự và ký tự chữ thường chỉ theo sau ký tự có ký tự. Trả lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 nếu khôngstr. ăn tối[]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu tất cả các ký tự viết hoa trong chuỗi là chữ hoa và có ít nhất một ký tự viết hoa, 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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 615str. tham gia[có thể lặp lại]
Trả về một chuỗi là chuỗi nối của các chuỗi trong iterable. A sẽ được nâng lên nếu có bất kỳ giá trị không phải chuỗi nào có thể lặp lại, bao gồm cả các đối tượng. Dấu phân cách giữa các phần tử là chuỗi cung cấp phương thức này
str. ljust[chiều rộng[ , fillchar]]Trả lại chuỗi căn trái trong một chuỗi có chiều dài chiều rộng. Việc đệm được thực hiện bằng cách sử dụng ký tự điền được chỉ định [mặc định là không gian ASCII]. Chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413str. thấp hơn[]
Trả về một bản sao của chuỗi với tất cả các ký tự có hoa văn được chuyển đổi thành chữ thường
Thuật toán viết thường được sử dụng được mô tả trong phần 3. 13 của Tiêu chuẩn Unicode
str. lstrip[[ký tự]]Trả về một bản sao của chuỗi đã xóa các ký tự đầu. Đối số ký tự là một chuỗi chỉ định bộ ký tự sẽ bị xóa. Nếu bị bỏ qua hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, đối số ký tự mặc định xóa khoảng trắng. Đối số ký tự không phải là tiền tố;
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 616
Xem phương pháp sẽ xóa một chuỗi tiền tố thay vì tất cả một bộ ký tự. 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'] --> 617tĩnh str. maketrans[x[ , y[, z]]]
Phương thức tĩnh này trả về một bảng dịch có thể sử dụng được cho
Nếu chỉ có một đối số, thì đó phải là một từ điển ánh xạ thứ tự Unicode [số nguyên] hoặc ký tự [chuỗi có độ dài 1] thành thứ tự Unicode, chuỗi [có độ dài tùy ý] hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631. Các phím ký tự sau đó sẽ được chuyển đổi thành thứ tự
Nếu có hai đối số, chúng phải là các chuỗi có độ dài bằng nhau và trong từ điển kết quả, mỗi ký tự trong x sẽ được ánh xạ tới ký tự ở cùng vị trí trong y. Nếu có đối số thứ ba, nó phải là một chuỗi, các ký tự của nó sẽ được ánh xạ tớ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 trong kết quảstr. phân vùng[sep]
Tách chuỗi ở lần xuất hiện đầu tiên của sep và trả về 3-tuple chứa phần trước dấu tách, chính dấu tách và phần sau dấu tách. Nếu không tìm thấy dấu tách, hãy trả về 3-bộ chứa chính chuỗi đó, theo sau là hai chuỗi trống
str. removeprefix[prefix , /]Nếu chuỗi bắt đầu bằng chuỗi tiền tố, hãy 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'] --> 62425. Nếu không, hãy trả về một bản sao của chuỗi gố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'] --> 618
Mới trong phiên bản 3. 9
str. hậu tố loại bỏ[hậu tố , /]Nếu chuỗi kết thúc bằng chuỗi hậu tố và hậu tố đó không trống, hãy trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62426. Nếu không, hãy trả về một bản sao của chuỗi gố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'] --> 619
Mới trong phiên bản 3. 9
str. thay thế[cũ , mới[, count]]Trả về một bản sao của chuỗi với tất cả các lần xuất hiện của chuỗi con cũ được thay thế bằng chuỗi mới. Nếu số lượng đối số tùy chọn được cung cấp, chỉ những lần xuất hiện đầu tiên được thay thế
str. rfind[phụ[ , start[, end]]]Trả về chỉ số cao nhất trong chuỗi nơi tìm thấy chuỗi con sub, sao cho sub đó được chứa trong
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62149. Các đối số tùy chọn bắt đầu và kết thúc được diễn giải như trong ký hiệu lát cắt. Trả lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6141 khi thất bạistr. rindex[sub[ , start[, end]]]
Like nhưng tăng khi không tìm thấy chuỗi con sub
str. rjust[chiều rộng[ , fillchar]]Trả về chuỗi được căn phải trong một chuỗi có chiều dài chiều rộng. Việc đệm được thực hiện bằng cách sử dụng ký tự điền được chỉ định [mặc định là không gian ASCII]. Chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413str. phân vùng[sep]
Tách chuỗi ở lần xuất hiện cuối cùng của sep và trả về 3 bộ chứa phần trước dấu phân cách, chính dấu phân cách và phần sau dấu phân cách. Nếu không tìm thấy dấu tách, hãy trả về 3-tuple chứa hai chuỗi trống, theo sau là chính chuỗi đó
str. rsplit[sep=Không có, maxsplit=- 1]Trả về danh sách các từ trong chuỗi, sử dụng sep làm chuỗi phân cách. Nếu maxsplit được đưa ra, thì tối đa các phần tách maxsplit được thực hiện, những phần ngoài cùng bên phải. Nếu sep không được chỉ định hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, thì bất kỳ chuỗi khoảng trắng nào cũng là dấu phân cách. Ngoại trừ tách từ bên phải, hoạt động như được mô tả chi tiết bên dướistr. rstrip[[ký tự]]
Trả về một bản sao của chuỗi đã xóa các ký tự ở cuối. Đối số ký tự là một chuỗi chỉ định bộ ký tự sẽ bị xóa. Nếu bị bỏ qua hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, đối số ký tự mặc định xóa khoảng trắng. Đối số ký tự không phải là một hậu 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'] --> 6130
Xem một phương thức sẽ loại bỏ một chuỗi hậu tố thay vì tất cả một bộ ký tự. Ví dụ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6131str. tách[sep=Không có, maxsplit=- 1]
Trả về danh sách các từ trong chuỗi, sử dụng sep làm chuỗi phân cách. Nếu maxsplit được đưa ra, thì tối đa việc tách maxsplit được thực hiện [do đó, danh sách sẽ có tối đa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62437 phần tử]. Nếu maxsplit không được chỉ định hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6141, thì không có giới hạn về số lần phân tách [tất cả các lần phân tách có thể được thực hiện]
Nếu sep được đưa ra, các dấu phân cách liên tiếp không được nhóm lại với nhau và được coi là phân cách các chuỗi trống [ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62439 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'] --> 62440]. Đối số sep có thể bao gồm nhiều ký tự [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'] --> 62441 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'] --> 62442]. Việc tách một chuỗi rỗng bằng một dấu tá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'] --> 62443
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'] --> 6132
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 tách khác sẽ được áp dụng. các khoảng trắng liên tiếp được coi là một dấu phân cách duy nhất và kết quả sẽ không chứa chuỗi trống ở đầu hoặc cuối nếu chuỗi có khoảng trắng ở đầu hoặc cuối. Do đó, việc tách một chuỗi rỗng hoặc một chuỗi chỉ bao gồm khoảng trắng bằng dấu phân cách
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631 trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 649
Ví dụ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6133str. đường phân chia[keepends=Sai]
Trả về danh sách các dòng trong chuỗi, phá vỡ ranh giới dòng. Ngắt dòng không được bao gồm trong danh sách kết quả trừ khi keepends được đưa ra và đúng
Phương pháp này phân chia trên các ranh giới dòng sau. Đặc biệt, các ranh giới là một siêu tập hợp của
đại diện
Sự miêu tả
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62147
Nguồn cấp dữ liệu 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'] --> 62148
Vận chuyển 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'] --> 62449
Trả lại vận chuyển + Nguồn cấp 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'] --> 62450 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'] --> 62451
Lập bảng 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'] --> 62452 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'] --> 62453
Thức ăn 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'] --> 62454
Trình tách 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'] --> 62455
Tách nhóm
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62456
Dấu tách bản ghi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62457
Dòng tiếp theo [Mã kiểm soát C1]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62458
Dấu phân cách 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'] --> 62459
Dấu phân cách đoạn văn
Đã thay đổi trong phiên bản 3. 2. ______12450 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'] --> 62452 được thêm vào danh sách ranh giới đườ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
Không giống như khi một chuỗi phân cách sep được đưa ra, phương thức này trả về một danh sách trống cho chuỗi trống và ngắt dòng ở cuối không dẫn đến một dòng thừa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6135
Để 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'] --> 62463 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'] --> 6136str. startswith[tiền tố[ , start[, end]]]
Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu chuỗi bắt đầu bằng tiền tố, ngược lại trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. tiền tố cũng có thể là một bộ tiền tố cần tìm. Với bắt đầu tùy chọn, chuỗi kiểm tra bắt đầu ở vị trí đó. Với kết thúc tùy chọn, dừng so sánh chuỗi tại vị trí đóstr. dải[[ký tự]]
Trả về một bản sao của chuỗi đã xóa các ký tự đầu và cuối. Đối số ký tự là một chuỗi chỉ định bộ ký tự sẽ bị xóa. Nếu bị bỏ qua hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, đối số ký tự mặc định xóa khoảng trắng. Đối số ký tự không phải là tiền tố hoặc hậu tố;
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6137
Các giá trị đối số ký tự đầu và cuối ngoài cùng bị loại bỏ khỏi chuỗi. Các ký tự bị xóa khỏi đầu cuối cho đến khi đạt đến một ký tự chuỗi không có trong bộ ký tự trong ký tự. Một hành động tương tự diễn ra ở cuối đuôi. 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'] --> 6138str. hoán đổi[]
Trả về một bản sao của chuỗi với các ký tự hoa được chuyển đổi thành chữ thường và ngược lại. Lưu ý rằng không nhất thiết phải đúng 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'] --> 62467str. tiêu đề[]
Trả về phiên bản có tiêu đề của chuỗi trong đó các từ bắt đầu bằng ký tự viết hoa và các ký tự còn lại là chữ thường
Ví dụ
def bit_length[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
Thuật toán sử dụng một định nghĩa đơn giản không phụ thuộc vào ngôn ngữ của một từ dưới dạng các nhóm chữ cái liên tiếp. Định nghĩa hoạt động trong nhiều ngữ cảnh nhưng nó có nghĩa là dấu nháy đơn trong các từ rút gọn và sở hữu tạo thành ranh giới từ, có thể không phải là kết quả mong muốn
def bit_length[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
Hàm này không gặp sự cố này vì nó chỉ tách các từ trên khoảng trắng
Ngoài ra, có thể xây dựng giải pháp thay thế cho dấu nháy đơn bằng cách sử dụng biểu thức chính quy
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6141str. dịch[bảng]
Trả về một bản sao của chuỗi trong đó mỗi ký tự đã được ánh xạ qua bảng dịch đã cho. Bảng phải là một đối tượng thực hiện lập chỉ mục thông qua
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62469, thường là một hoặc. Khi được lập chỉ mục bởi một thứ tự Unicode [một số nguyên], đối tượng bảng có thể thực hiện bất kỳ thao tác nào sau đây. trả về một thứ tự Unicode hoặc một chuỗi, để ánh xạ ký tự tới một hoặc nhiều ký tự khác;
Bạn có thể sử dụng để tạo bản đồ dịch từ ánh xạ ký tự sang ký tự ở các định dạng khác nhau
Xem thêm mô-đun để biết cách tiếp cận linh hoạt hơn đối với ánh xạ ký tự tùy chỉnh
str. trên[]Trả về một bản sao của chuỗi với tất cả các ký tự được viết hoa được chuyển đổi thành chữ hoa. Lưu ý rằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62474 có thể là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638 nếu
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62194 chứa các ký tự không có chữ hoa hoặc nếu danh mục Unicode của [các] ký tự kết quả không phải là “Lu” [Chữ cái, chữ hoa], mà là e. g. “Lt” [Thư, tựa đề]
Thuật toán viết hoa được sử dụng được mô tả trong phần 3. 13 của Tiêu chuẩn Unicode
str. zfill[chiều rộng]Trả về một bản sao của chuỗi còn lại chứa các chữ số 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'] --> 62477 để tạo một chuỗi có chiều dài chiều rộng. Tiền tố dấu hiệu ở đầ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'] --> 62478/______12479] được xử lý bằng cách chèn phần đệm sau ký tự dấu hiệu thay vì trước. Chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413
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'] --> 6142
Định dạng chuỗi 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
2126
Ghi chú
Các hoạt động định dạng được mô tả ở đây thể hiện nhiều điểm kỳ quặc dẫn đến một số lỗi phổ biến [chẳng hạn như không hiển thị chính xác các bộ dữ liệu và từ điển]. Sử dụng giao diện mới hơn hoặc có thể giúp tránh những lỗi này. Mỗi lựa chọn thay thế này cung cấp sự đánh đổi và lợi ích của riêng chúng về tính đơn giản, tính linh hoạt và/hoặc khả năng mở rộng
Các đối tượng chuỗi có một thao tác tích hợp duy nhất. 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'] --> 62483 [mô-đun]. Điều này còn được gọi là định dạng chuỗi hoặc toán tử nội suy. Cho trước
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62484 [trong đó định dạng là một chuỗi], thông số kỹ thuật chuyển đổi 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'] --> 62483 ở định dạng được thay thế bằng 0 hoặc nhiều phần tử giá trị. Hiệu quả tương tự như 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'] --> 62486 trong ngôn ngữ C
Nếu định dạng yêu cầu một đối số duy nhất, các giá trị có thể là một đối tượng không phải bộ dữ liệu. Nếu không, các giá trị phải là một bộ có số mục chính xác được chỉ định bởi chuỗi định dạng hoặc một đối tượng ánh xạ đơn lẻ [ví dụ: từ điển]
Trình xác định chuyển đổi chứa hai hoặc nhiều ký tự và có các thành phần sau, phải xảy ra theo thứ tự này
Ký tự
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2487, đánh dấu sự bắt đầu của trình xác địnhKhóa ánh xạ [tùy chọn], bao gồm một chuỗi ký tự trong ngoặc đơn [ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2488]Cờ chuyển đổi [tùy chọn], ảnh hưởng đến kết quả của một số loại chuyển đổi
Độ rộng trường tối thiểu [tùy chọn]. Nếu được chỉ định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2489 [dấu hoa thị], chiều rộng thực tế được đọc từ phần tử tiếp theo của bộ giá trị và đối tượng cần chuyển đổi xuất hiện sau chiều rộng trường tối thiểu và độ chính xác tùy chọnĐộ chính xác [tùy chọn], được cho dưới dạng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2490 [dấu chấm] theo sau là độ chính xác. Nếu được chỉ định làdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2489 [dấu hoa thị], thì độ chính xác thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu theo giá trị và giá trị để chuyển đổi xuất hiện sau độ chính xácCông cụ sửa đổi độ dài [tùy chọn]
loại chuyển đổi
Khi đối số bên phải là từ điển [hoặc loại ánh xạ khác], thì các định dạng trong chuỗi phải bao gồm khóa ánh xạ trong ngoặc đơn vào từ điển đó được chèn ngay sau ký tự
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62487. Phím ánh xạ chọn giá trị được định dạng từ ánh xạ. 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'] --> 6143
Trong trường hợp này, không có trình xá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'] --> 61400 nào có thể xuất hiện ở định dạng [vì chúng yêu cầu danh sách tham số tuần tự]
Các ký tự cờ chuyển đổi là
Lá cờ
Nghĩa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62494
Việc chuyển đổi giá trị sẽ sử dụng “hình thức thay thế” [được định nghĩa bên dưới]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62477
Chuyển đổi sẽ được đệm bằng 0 cho các giá trị 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'] --> 62479
Giá trị chuyển đổi được điều chỉnh trái [ghi đè chuyển đổ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'] --> 62477 nếu cả hai được cung 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'] --> 62498
[khoảng trắng] Nên để trống trước số dương [hoặc chuỗi trống] được tạo bởi chuyển đổi đã ký
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62478
Một ký tự dấ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'] --> 62478 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'] --> 62479] sẽ đứng trước chuyển đổi [ghi đè cờ “dấu cách”]
Có thể có công cụ sửa đổi độ 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'] --> 62802,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62803 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'] --> 62804], nhưng bị bỏ qua vì nó không cần thiết cho Python – vì vậy 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'] --> 62805 giống hệ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'] --> 62806
Các loại chuyển đổi là
chuyển đổi
Nghĩa
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'] --> 62807
Số thập phân có dấ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'] --> 62808
Số thập phân có dấ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'] --> 62809
Giá trị bát phân đã ký
[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'] --> 62810
Loại lỗi thời – nó giống hệ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'] --> 62807
[6]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62812
Đã ký thập lục phân [chữ thường]
[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'] --> 62813
Đã ký thập lục phân [chữ hoa]
[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'] --> 62814
Định dạng số mũ dấu phẩy động [chữ thường]
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62815
Định dạng số mũ dấu phẩy động [chữ hoa]
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62816
Định dạng thập phân dấu phẩy động
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62817
Định dạng thập phân dấu phẩy động
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62818
Định dạng dấu phẩy động. Sử dụng định dạng số mũ chữ thường nếu số mũ nhỏ hơn -4 hoặc không nhỏ hơn độ chính xác, nếu không thì định dạng thập phân
[4]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62819
Định dạng dấu phẩy động. Sử dụng định dạng số mũ viết hoa nếu số mũ nhỏ hơn -4 hoặc không nhỏ hơn độ chính xác, nếu không thì định dạng thập phân
[4]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62820
Ký tự đơn [chấp nhận số nguyên hoặc chuỗi ký tự đơ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'] --> 62821
Chuỗi [chuyển đổi bất kỳ đối tượng Python nào bằng cách sử dụng]
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62823
Chuỗi [chuyển đổi bất kỳ đối tượng Python nào bằng cách sử dụng]
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62825
Chuỗi [chuyển đổi bất kỳ đối tượng Python nào bằng cách sử dụng]
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62487
Không có đối số nào được chuyển đổi, dẫn đến ký 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'] --> 62487 trong kết quả
ghi chú
Dạng thay thế làm cho một bộ xác định bát phân hàng đầ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
2829] được chèn vào trước chữ số đầu tiênDạng thay thế làm cho một số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2830 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
2831 đứng đầu [tùy thuộc vào việc sử dụng định dạ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
2812 haydef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2813] trước chữ số đầu tiênDạng thay thế khiến kết quả luôn chứa dấu thập phân, ngay cả khi không có chữ số nào theo sau nó
Độ chính xác xác định số chữ số sau dấu thập phân và mặc định là 6
Dạng thay thế làm cho kết quả luôn chứa dấu thập phân và các số 0 ở cuối không bị xóa như cách khác
Độ chính xác xác định số chữ số có nghĩa trước và sau dấu thập phân và mặc định là 6
Nếu độ chính xá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'] --> 6
2834, đầu ra bị cắt bớt thành ký 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
2834Xem PEP 237
Vì các chuỗi Python có độ dài rõ ràng, các chuyển đổi 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'] --> 62836 không cho rằ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'] --> 62837 là phần cuối của chuỗi
Đã thay đổi trong phiên bản 3. 1. ______12838 chuyển đổi cho các số có giá trị tuyệt đối trên 1e50 không còn được thay thế bằng chuyển đổ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'] --> 62839.
Các loại chuỗi nhị phân — , ,
Các loại tích hợp cốt lõi để thao tác dữ liệu nhị phân là và. Chúng được hỗ trợ bằng cách sử dụng để truy cập bộ nhớ của các đối tượng nhị phân khác mà không cần tạo bản sao
Mô-đun này hỗ trợ lưu trữ hiệu quả các loại dữ liệu cơ bản như số nguyên 32 bit và giá trị nổi chính xác kép IEEE754
đối tượng byte
Các đối tượng byte là các chuỗi bất biến của các byte đơn. Do nhiều giao thức nhị phân chính dựa trên mã hóa văn bản ASCII, các đối tượng byte cung cấp một số phương thức chỉ hợp lệ khi làm việc với dữ liệu tương thích ASCII và có liên quan chặt chẽ với các đối tượng chuỗi theo nhiều cách khác nhau
lớp byte[[nguồn[, encoding[, errors]]]]Đầu tiên, cú pháp cho các ký tự byte phần lớn giống như cú pháp cho các ký tự chuỗi, ngoại trừ tiề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'] --> 62847 được thêm vào
Dấu nháy đơ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
2848Dấu ngoặc ké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
2849Ba trích dẫ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
2850,def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2851
Chỉ cho phép các ký tự ASCII theo byte bằng chữ [bất kể mã hóa mã nguồn đã khai báo]. Bất kỳ giá trị nhị phân nào trên 127 phải được nhập vào byte bằng chữ bằng cách sử dụng trình tự thoát thích hợp
Như với chuỗi ký tự, ký tự byte cũng có thể sử dụng tiề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'] --> 62062 để vô hiệu hóa quá trình xử lý chuỗi thoát. Xem để biết thêm về các dạng byte chữ khác nhau, bao gồm các chuỗi thoát được hỗ trợ
Mặc dù các ký tự byte và biểu diễn dựa trên văn bản ASCII, nhưng các đối tượng byte thực sự hoạt động giống như các chuỗi số nguyên bất biến, với mỗi giá trị trong chuỗi bị hạn chế sao 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'] --> 62853 [cố gắng vi phạm hạn chế này sẽ kích hoạt ]. Điều này được thực hiện có chủ ý để nhấn mạnh rằng mặc dù nhiều định dạng nhị phân bao gồm các phần tử dựa trên ASCII và có thể được thao tác hữu ích với một số thuật toán hướng văn bản, nhưng điều này thường không đúng với dữ liệu nhị phân tùy ý [áp dụng một cách mù quáng các thuật toán xử lý văn bản cho các định dạng dữ liệu nhị phân không phải là
Ngoài các dạng chữ, các đối tượng byte có thể được tạo theo một số cách khác
Một đối tượng byte được điền bằng 0 có độ dài được chỉ đị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
2855Từ một số nguyên có thể lặp lại.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2856Sao chép dữ liệu nhị phân hiện có thông qua giao thức bộ đệm.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2857
Cũng xem tích hợp
Vì 2 chữ số thập lục phân tương ứng chính xác với một byte đơn, số thập lục phân là định dạng thường được sử dụng để mô tả dữ liệu nhị phân. Theo đó, kiểu bytes có thêm một phương thức lớp để đọc dữ liệu ở định dạng đó
phương pháp phân lớp từ hex[chuỗi]Phương thức lớp này trả về một đối tượng byte, giải mã đối tượng chuỗi đã cho. Chuỗi phải chứa hai chữ số thập lục phân trên mỗi byte, bỏ qua khoảng trắng 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'] --> 6144
Đã thay đổi trong phiên bản 3. 7. hiện bỏ qua tất cả khoảng trắng ASCII trong chuỗi, không chỉ khoảng trắng.
Hàm chuyển đổi ngược tồn tại để chuyển đổi một đối tượng byte thành biểu diễn thập lục phân của nó
hex[[sep[, bytes_per_sep]]]Trả về một đối tượng chuỗi chứa hai chữ số thập lục phân cho mỗi byte trong 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'] --> 6145
Nếu bạn muốn làm cho chuỗi hex dễ đọc hơn, bạn có thể chỉ định một tham số sep tách ký tự đơn để đưa vào đầu ra. Theo mặc định, dấu tách này sẽ được bao gồm giữa mỗi byte. Tham số bytes_per_sep tùy chọn thứ hai kiểm soát khoảng cách. Các giá trị dương tính toán vị trí phân cách từ bên phải, các giá trị âm từ bên trá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'] --> 6146
Mới trong phiên bản 3. 5
Đã thay đổi trong phiên bản 3. 8. hiện hỗ trợ các tham số sep và bytes_per_sep tùy chọn để chèn dấu phân cách giữa các byte trong đầu ra hex.
Vì đối tượng bytes là chuỗi các số nguyên [tương tự như bộ tuple], đối với đối tượng bytes 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'] --> 62861 sẽ là số nguyên, trong khi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62862 sẽ là đối tượng bytes có độ dài 1. [Điều này trái ngược với các chuỗi văn bản, trong đó cả lập chỉ mục và cắt sẽ tạo ra một chuỗi có độ dài 1]
Việc biểu diễn các đối tượng byte sử dụng định dạng 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'] --> 62863] vì nó thường hữu ích 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'] --> 62864. Bạn luôn có thể chuyển đổi đối tượng byte thành danh sách số nguyên 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'] --> 62865
Đối tượng Bytearray
các đối tượng là một đối tác có thể thay đổi đối với các đối tượng
lớp dải byte[[nguồn[, encoding[, errors]]]]Không có cú pháp theo nghĩa đen dành riêng cho các đối tượng bytearray, thay vào đó chúng luôn được tạo bằng cách gọi hàm tạo
Tạo một phiên bản 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
2868Tạo một phiên bản không chứa đầy với độ dài nhấ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
2869Từ một số nguyên có thể lặp lại.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2870Sao chép dữ liệu nhị phân hiện có thông qua giao thức bộ đệm.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2871
Vì các đối tượng mảng phụ có thể thay đổi, nên chúng hỗ trợ các hoạt động tuần tự ngoài các hoạt động byte và mảng phụ phổ biến được mô tả trong
Cũng xem tích hợp
Vì 2 chữ số thập lục phân tương ứng chính xác với một byte đơn, số thập lục phân là định dạng thường được sử dụng để mô tả dữ liệu nhị phân. Theo đó, kiểu bytearray có thêm một phương thức lớp để đọc dữ liệu ở định dạng đó
phương pháp phân lớp từ hex[chuỗi]Phương thức lớp này trả về đối tượng bytearray, giải mã đối tượng chuỗi đã cho. Chuỗi phải chứa hai chữ số thập lục phân trên mỗi byte, bỏ qua khoảng trắng 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'] --> 6147
Đã thay đổi trong phiên bản 3. 7. hiện bỏ qua tất cả khoảng trắng ASCII trong chuỗi, không chỉ khoảng trắng.
Hàm chuyển đổi ngược tồn tại để chuyển đổi một đối tượng bytearray thành biểu diễn thập lục phân của nó
hex[[sep[, bytes_per_sep]]]Trả về một đối tượng chuỗi chứa hai chữ số thập lục phân cho mỗi byte trong 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'] --> 6148
Mới trong phiên bản 3. 5
Đã thay đổi trong phiên bản 3. 8. Tương tự như , giờ đây hỗ trợ các tham số sep và bytes_per_sep tùy chọn để chèn dấu phân cách giữa các byte trong đầu ra hex.
Vì các đối tượng bytearray là chuỗi các số nguyên [tương tự như một danh sách], đối với một đối tượng bytearray 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'] --> 62861 sẽ là một số nguyên, trong khi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62862 sẽ là một đối tượng bytearray có độ dài 1. [Điều này trái ngược với các chuỗi văn bản, trong đó cả lập chỉ mục và cắt sẽ tạo ra một chuỗi có độ dài 1]
Việc biểu diễn các đối tượng bytearray sử dụng định dạng byte bằng 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'] --> 62878] vì nó thường hữu ích 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'] --> 62879. Bạn luôn có thể chuyển đổi một đối tượng bytearray thành một danh sách các số nguyên 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'] --> 62865
Byte và hoạt động Bytearray
Cả hai đối tượng byte và bytearray đều hỗ trợ các hoạt động trình tự. Chúng tương tác với nhau không chỉ với các toán hạng cùng loại mà với bất kỳ. Do tính linh hoạt này, chúng có thể được trộn lẫn tự do trong các hoạt động mà không gây ra lỗi. Tuy nhiên, kiểu trả về của kết quả có thể phụ thuộc vào thứ tự của các toán hạng
Ghi chú
Các phương thức trên các đối tượng byte và bytearray không chấp nhận các chuỗi làm đối số của chúng, giống như các phương thức trên các chuỗi không chấp nhận các byte làm đối số của chúng. Ví dụ, bạn phải 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'] --> 6149
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'] --> 6200
Một số thao tác byte và bytearray giả sử sử dụng các định dạng nhị phân tương thích ASCII và do đó nên tránh khi làm việc với dữ liệu nhị phân tùy ý. Những hạn chế này được đề cập dưới đây
Ghi chú
Sử dụng các hoạt động dựa trên ASCII này để thao tác dữ liệu nhị phân không được lưu trữ ở định dạng dựa trên ASCII có thể dẫn đến hỏng dữ liệu
Có thể sử dụng các phương thức sau trên đối tượng byte và bytearray với dữ liệu nhị phân tùy ý
byte. đếm[phụ[ , . start[, end]]]bytearray.đếm[phụ[ , start[, end]]]Trả về số lần xuất hiện không trùng lặp của subsequence sub trong phạm vi [bắt đầu, kết thúc]. Các đối số tùy chọn bắt đầu và kết thúc được diễn giải như trong ký hiệu lát cắt
Dãy con cần tìm có thể là bất kỳ hoặc một số nguyên trong khoảng từ 0 đến 255
Nếu phụ trống, trả về số lát trống giữa các ký tự là độ dài của đối tượng byte cộng với một
Đã thay đổi trong phiên bản 3. 3. Cũng chấp nhận một số nguyên trong khoảng từ 0 đến 255 làm dãy con.
byte. removeprefix[prefix , / . ]bytearray.removeprefix[prefix , /]Nếu dữ liệu nhị phân bắt đầu bằng chuỗi tiền tố, hãy 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'] --> 62881. Mặt khác, trả về một bản sao của dữ liệu nhị phân ban đầ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'] --> 6201
Tiền tố có thể là bất kỳ
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
Mới trong phiên bản 3. 9
byte. hậu tố loại bỏ[hậu tố , / . ]bytearray.hậu tố loại bỏ[hậu tố , /]Nếu dữ liệu nhị phân kết thúc bằng chuỗi hậu tố và hậu tố đó không trống, hãy 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'] --> 62882. Mặt khác, trả về một bản sao của dữ liệu nhị phân ban đầ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'] --> 6202
Hậu tố có thể là bất kỳ
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
Mới trong phiên bản 3. 9
byte. giải mã[mã hóa=' . , errors='strict']bytearray.giải mã[mã hóa=', errors='strict']Trả lại các byte được giải mã thành một
mã hóa mặc định 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'] --> 62136;
lỗi kiểm soát cách xử lý lỗi giải mã. 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'] --> 62137 [mặc định], một ngoại lệ được đưa ra. Các giá trị có thể khá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'] --> 62139,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62140 và bất kỳ tên nào khác được đăng ký qua. Xem để biết chi tiết
Vì lý do hiệu suất, giá trị của lỗi không được kiểm tra tính hợp lệ trừ khi lỗi giải mã thực sự xảy ra, được bật hoặc được sử dụng
Ghi chú
Truyền đối số mã hóa để cho phép giải mã bất kỳ trực tiếp nào mà không cần tạo đối tượng tạm thờ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'] --> 61423 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'] --> 61424
Đã thay đổi trong phiên bản 3. 1. Đã thêm hỗ trợ cho đối số từ khóa.
Đã thay đổi trong phiên bản 3. 9. Giá trị của đối số lỗi hiện được kiểm tra trong và trong.
byte. endswith[hậu tố[ , . start[, end]]]bytearray.endswith[hậu tố[ , start[, end]]]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu dữ liệu nhị phân kết thúc bằng hậu tố đã chỉ định, nếu không thì trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 638. hậu tố cũng có thể là một bộ hậu tố cần tìm. Với bắt đầu tùy chọn, bắt đầu kiểm tra tại vị trí đó. Với đầu cuối tùy chọn, dừng so sánh tại vị trí đó
[Các] hậu tố để tìm kiếm có thể là bất kỳ
byte. tìm[phụ[ , . start[, end]]]bytearray.tìm[phụ[ , start[, end]]]Trả về chỉ số thấp nhất trong dữ liệu nơi tìm thấy subsequence sub, sao cho sub đó được chứa trong lát cắ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'] --> 62149. Các đối số tùy chọn bắt đầu và kết thúc được diễn giải như trong ký hiệu lát cắt. Trả lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6141 nếu không tìm thấy sub
Dãy con cần tìm có thể là bất kỳ hoặc một số nguyên trong khoảng từ 0 đến 255
Ghi chú
Phương pháp này chỉ nên được sử dụng nếu bạn cần biết vị trí của phụ. Để kiểm tra sub có phải là xâu con hay không ta dùng 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'] --> 6203
Đã thay đổi trong phiên bản 3. 3. Cũng chấp nhận một số nguyên trong khoảng từ 0 đến 255 làm dãy con.
byte. chỉ mục[phụ[ , . start[, end]]]bytearray.chỉ mục[phụ[ , start[, end]]]Thích , nhưng tăng khi không tìm thấy dãy con
Dãy con cần tìm có thể là bất kỳ hoặc một số nguyên trong khoảng từ 0 đến 255
Đã thay đổi trong phiên bản 3. 3. Cũng chấp nhận một số nguyên trong khoảng từ 0 đến 255 làm dãy con.
byte. tham gia[có thể lặp lại]bytearray. tham gia[có thể lặp lại]Trả về một byte hoặc đối tượng bytearray là sự kết hợp của các chuỗi dữ liệu nhị phân trong iterable. A sẽ được nâng lên nếu có bất kỳ giá trị nào trong iterable không có, bao gồm cả các đối tượng. Dấu phân cách giữa các phần tử là nội dung của đối tượng byte hoặc bytearray cung cấp phương thức này
tĩnh byte. maketrans[từ , đến . ]static bytearray.maketrans[từ , đến]Phương thức tĩnh này trả về một bảng dịch có thể sử dụng để ánh xạ từng ký tự từ thành ký tự ở cùng một vị trí thành;
Mới trong phiên bản 3. 1
byte. phân vùng[sep]bytearray. phân vùng[sep]Tách chuỗi ở lần xuất hiện đầu tiên của sep và trả về 3-tuple chứa phần trước dấu tách, chính dấu tách hoặc bản sao mảng phụ của nó và phần sau dấu tách. Nếu không tìm thấy dấu tách, hãy trả về 3-tuple chứa bản sao của chuỗi ban đầu, theo sau là hai byte trống hoặc đối tượng mảng phụ
Dấu phân cách để tìm kiếm có thể là bất kỳ
byte. thay thế[cũ , mới . [, count]]bytearray.thay thế[cũ , mới[, count]]Trả về một bản sao của chuỗi với tất cả các lần xuất hiện của chuỗi cũ được thay thế bằng mới. Nếu số lượng đối số tùy chọn được cung cấp, chỉ những lần xuất hiện đầu tiên được thay thế
Dãy con cần tìm và sự thay thế của nó có thể là bất kỳ
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
byte. rfind[phụ[ , . start[, end]]]bytearray.rfind[sub[ , start[, end]]]Trả về chỉ mục cao nhất trong chuỗi nơi tìm thấy subsequence sub, sao cho sub đó được chứa 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'] --> 62149. Các đối số tùy chọn bắt đầu và kết thúc được diễn giải như trong ký hiệu lát cắt. Trả lại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6141 khi thất bại
Dãy con cần tìm có thể là bất kỳ hoặc một số nguyên trong khoảng từ 0 đến 255
Đã thay đổi trong phiên bản 3. 3. Cũng chấp nhận một số nguyên trong khoảng từ 0 đến 255 làm dãy con.
byte. rindex[sub[ , . start[, end]]]bytearray.rindex[sub[ , start[, end]]]Like nhưng tăng khi không tìm thấy sub nối tiếp
Dãy con cần tìm có thể là bất kỳ hoặc một số nguyên trong khoảng từ 0 đến 255
Đã thay đổi trong phiên bản 3. 3. Cũng chấp nhận một số nguyên trong khoảng từ 0 đến 255 làm dãy con.
byte. phân vùng[sep]bytearray. phân vùng[sep]Tách chuỗi ở lần xuất hiện cuối cùng của sep và trả về 3-tuple chứa phần trước dấu tách, chính dấu tách hoặc bản sao mảng phụ của nó và phần sau dấu tách. Nếu không tìm thấy dấu tách, hãy trả về 3-bộ chứa hai byte trống hoặc đối tượng mảng phụ, theo sau là bản sao của chuỗi ban đầu
Dấu phân cách để tìm kiếm có thể là bất kỳ
byte. startswith[tiền tố[ , . start[, end]]]bytearray.startswith[tiền tố[ , start[, end]]]Trả về
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 656 nếu 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. tiền tố cũng có thể là một bộ tiền tố cần tìm. Với bắt đầu tùy chọn, bắt đầu kiểm tra tại vị trí đó. Với đầu cuối tùy chọn, dừng so sánh tại vị trí đó
[Các] tiền tố để tìm kiếm có thể là bất kỳ
byte. dịch[bảng , / . , delete=b'']bytearray.dịch[bảng , /, delete=b'']Trả về một bản sao của đối tượng byte hoặc bytearray trong đó tất cả các byte xuất hiện trong thao tác xóa đối số tùy chọn đều bị xóa và các byte còn lại đã được ánh xạ qua bảng dịch đã cho, phải là một đối tượng byte có độ dài 256
Bạn có thể sử dụng phương pháp để tạo bảng dịch
Đặt đối số bảng 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'] --> 631 cho các bản dịch chỉ xóa các ký 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'] --> 6204
Đã thay đổi trong phiên bản 3. 6. xóa hiện được hỗ trợ làm đối số từ khóa.
Các phương thức sau trên các đối tượng byte và bytearray có các hành vi mặc định giả sử sử dụng các định dạng nhị phân tương thích ASCII, nhưng vẫn có thể được sử dụng với dữ liệu nhị phân tùy ý bằng cách chuyển các đối số thích hợp. 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
byte. trung tâm[chiều rộng[ , . fillbyte]]bytearray.trung tâm[chiều rộng[ , fillbyte]]Trả về một bản sao của đối tượng được căn giữa theo thứ tự chiều dài chiều rộng. Quá trình đệm được thực hiện bằng cách sử dụng fillbyte đã chỉ định [mặc định là một không gian ASCII]. Đố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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
byte. ljust[chiều rộng[ , . fillbyte]]bytearray.ljust[chiều rộng[ , fillbyte]]Trả về một bản sao của đối tượng còn lại được căn đều theo trình tự chiều dài chiều rộng. Quá trình đệm được thực hiện bằng cách sử dụng fillbyte đã chỉ định [mặc định là một không gian ASCII]. Đố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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
byte. lstrip[[ký tự] . ]bytearray.lstrip[[ký tự]]Trả về một bản sao của chuỗi đã xóa các byte đầu được chỉ định. Đối số ký tự là một chuỗi nhị phân chỉ định tập hợp các giá trị byte sẽ bị xóa - tên đề cập đến thực tế là phương thức này thường được sử dụng với các ký tự ASCII. Nếu bỏ qua hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, đối số ký tự mặc định xóa khoảng trắng ASCII. Đối số ký tự không phải là tiề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'] --> 6205
Chuỗi nhị phân của các giá trị byte cần loại bỏ có thể là bất kỳ. Xem phương pháp sẽ xóa một chuỗi tiền tố thay vì tất cả một bộ ký tự. 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'] --> 6206
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
byte. rjust[chiều rộng[ , . fillbyte]]bytearray.rjust[chiều rộng[ , fillbyte]]Trả về một bản sao của đối tượng được căn phải theo thứ tự chiều dài chiều rộng. Quá trình đệm được thực hiện bằng cách sử dụng fillbyte đã chỉ định [mặc định là một không gian ASCII]. Đố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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61413
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
byte. rsplit[sep=Không có . , maxsplit=- 1]bytearray.rsplit[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, thì tối đa các phần tách maxsplit được thực hiện, những phần ngoài cùng bên phải. Nếu sep không được chỉ định hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, bất kỳ dãy con nào chỉ chứa khoảng trắng ASCII đều là dấu phân cách. Ngoại trừ tách từ bên phải, hoạt động như được mô tả chi tiết bên dướibyte. rstrip[[ký tự] . ]bytearray.rstrip[[ký tự]]
Trả về một bản sao của chuỗi đã xóa các byte theo sau được chỉ định. Đối số ký tự là một chuỗi nhị phân chỉ định tập hợp các giá trị byte sẽ bị xóa - tên đề cập đến thực tế là phương thức này thường được sử dụng với các ký tự ASCII. Nếu bỏ qua hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, đối số ký tự mặc định xóa khoảng trắng ASCII. Đối số ký tự không phải là một hậu 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'] --> 6207
Chuỗi nhị phân của các giá trị byte cần loại bỏ có thể là bất kỳ. Xem một phương thức sẽ loại bỏ một chuỗi hậu tố thay vì tất cả một bộ ký tự. Ví dụ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6208
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62437 phần tử]. Nếu maxsplit 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'] --> 6141, 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ụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63327 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'] --> 63328]. Đối số sep có thể bao gồm một chuỗi nhiều byte [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'] --> 63329 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'] --> 63330]. Tách một chuỗi trống với một dấu phân cách được chỉ định 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'] --> 63331 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'] --> 63332 tùy thuộc vào loại đối tượng được tách. Đối số sep có thể là bất kỳ
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'] --> 6209
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 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 tá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
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'] --> 6210byte. dải[[ký tự] . ]bytearray.dải[[ký tự]]
Trả về một bản sao của chuỗi đã xóa các byte đầu và cuối được chỉ định. Đối số ký tự là một chuỗi nhị phân chỉ định tập hợp các giá trị byte sẽ bị xóa - tên đề cập đến thực tế là phương thức này thường được sử dụng với các ký tự ASCII. Nếu bỏ qua hoặc
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631, đối số ký tự mặc định xóa khoảng trắng ASCII. Đối số ký tự không phải là tiền tố hoặc hậu 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'] --> 6211
Chuỗi nhị phân của các giá trị byte cần loại bỏ có thể là bất kỳ
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
Các phương thức sau trên các đối tượng byte và bytearray giả sử sử dụng các định dạng nhị phân tương thích ASCII và không được áp dụng cho dữ liệu nhị phân tùy ý. 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
byte. viết hoa[]dãy byte. viết hoa[]Trả về một bản sao của chuỗi với mỗi byte được hiểu là ký tự ASCII và byte đầu tiên được viết hoa và phần còn lại được viết thường. Các giá trị byte không phải ASCII được chuyển qua không thay đổi
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
byte. tab mở rộng[kích thước tab=8 . ]bytearray.tab mở rộng[kích thước tab=8]Trả về một bản sao của chuỗi trong đó tất cả các ký tự tab ASCII được thay thế bằng một hoặc nhiều khoảng trắng ASCII, tùy thuộc vào cột hiện tại và kích thước tab đã cho. Vị trí tab xuất hiện ở mỗi byte kích thước tab [mặc định là 8, cung cấp vị trí tab tại các cột 0, 8, 16, v.v.]. Để mở rộng chuỗi, cột hiện tại được đặt thành 0 và chuỗi được kiểm tra từng byte. Nếu byte là ký tự tab ASCII [______13336], một hoặc nhiều ký tự khoảng trắng sẽ được chèn vào kết quả cho đến khi cột hiện tại bằng với vị trí tab tiếp theo. [Bản thân ký tự tab không được sao chép. ] Nếu byte hiện tại là một dòng mới ASCII [
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63337] hoặc ký tự xuống 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'] --> 63338], 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 bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6212
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63341. Các chữ số thập phân ASCII là các giá trị byte đó trong chuỗ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'] --> 63342
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'] --> 6213byte. 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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63341
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'] --> 6214byte. 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
Mới trong phiên bản 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. Các chữ số thập phân ASCII là các giá trị byte đó trong chuỗ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'] --> 63342
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'] --> 6215byte. 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
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'] --> 6216
Các ký tự ASCII chữ thường là các giá trị byte trong chuỗ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'] --> 63353. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗ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'] --> 63354byte. 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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63357 [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”
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'] --> 6217byte. 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
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'] --> 6218
Các ký tự ASCII chữ thường là các giá trị byte trong chuỗ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'] --> 63353. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗ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'] --> 63354byte. hạ[]bytearray. thấp hơn[]
Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ hoa được chuyển đổi thành chữ thường tương ứng của chúng
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'] --> 6219
Các ký tự ASCII chữ thường là các giá trị byte trong chuỗ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'] --> 63353. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗ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'] --> 63354
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
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
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'] --> 6240
Không giống như khi một chuỗi phân cách sep được đưa ra, phương thức này trả về một danh sách trống cho chuỗi trống và ngắt dòng ở cuối không dẫn đến một dòng thừa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6241byte. 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
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'] --> 6242
Các ký tự ASCII chữ thường là các giá trị byte trong chuỗ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'] --> 63353. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗ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'] --> 63354
Không giống như , luôn luôn xảy ra trường 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'] --> 63371 cho các phiên bản nhị phân. Chuyển đổi trường hợp là đối xứng trong ASCII, mặc dù điều đó thường không đúng đối với các điểm mã Unicode tùy ý
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
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
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'] --> 6243
Các ký tự ASCII chữ thường là các giá trị byte trong chuỗ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'] --> 63353. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗ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'] --> 63354. Tất cả các giá trị byte khác đều không có vỏ
Thuật toán sử dụng một định nghĩa đơn giản không phụ thuộc vào ngôn ngữ của một từ dưới dạng các nhóm chữ cái liên tiếp. Định nghĩa hoạt động trong nhiều ngữ cảnh nhưng nó có nghĩa là dấu nháy đơn trong các từ rút gọn và sở hữu tạo thành ranh giới từ, có thể không phải là kết quả mong muốn
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6244
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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6245
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
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
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'] --> 6246
Các ký tự ASCII chữ thường là các giá trị byte trong chuỗ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'] --> 63353. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗ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'] --> 63354
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
byte. zfill[chiều rộng]bytearray. zfill[chiều rộng]Trả về một bản sao của chuỗi còn lại chứa đầy các chữ số 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'] --> 63376 để tạo một chuỗi có chiều dài chiều rộng. Tiền tố dấu hiệu ở đầ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'] --> 63377/
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63378] đượ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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 63380
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'] --> 6247
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
Định dạng byte theo 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
2126
Ghi chú
Các hoạt động định dạng được mô tả ở đây thể hiện nhiều điểm kỳ quặc dẫn đến một số lỗi phổ biến [chẳng hạn như không hiển thị chính xác các bộ dữ liệu và từ điển]. Nếu giá trị được in có thể là một bộ hoặc từ điển, hãy bọc nó trong một bộ
Các đối tượng byte [
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61423/______11424] có một thao tác tích hợp duy nhất. 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'] --> 62483 [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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62484 [trong đó định dạng là đối tượng byte], thông số kỹ thuật chuyển đổi 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'] --> 62483 ở định dạng được thay thế bằng 0 hoặc nhiều phần tử giá trị. Hiệu quả tương tự như 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'] --> 62486 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]
Trình xác định chuyển đổi chứa hai hoặc nhiều ký tự và có các thành phần sau, phải xảy ra theo thứ tự này
Ký tự
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2487, đánh dấu sự bắt đầu của trình xác địnhKhóa ánh xạ [tùy chọn], bao gồm một chuỗi ký tự trong ngoặc đơn [ví dụ:
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2488]Cờ chuyển đổi [tùy chọn], ảnh hưởng đến kết quả của một số loại chuyển đổi
Độ rộng trường tối thiểu [tùy chọn]. Nếu được chỉ định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2489 [dấu hoa thị], chiều rộng thực tế được đọc từ phần tử tiếp theo của bộ giá trị và đối tượng cần chuyển đổi xuất hiện sau chiều rộng trường tối thiểu và độ chính xác tùy chọnĐộ chính xác [tùy chọn], được cho dưới dạng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2490 [dấu chấm] theo sau là độ chính xác. Nếu được chỉ định làdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2489 [dấu hoa thị], thì độ chính xác thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu theo giá trị và giá trị để chuyển đổi xuất hiện sau độ chính xácCông cụ sửa đổi độ dài [tùy chọn]
loại chuyển đổi
Khi đối số bên phải là 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ự
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62487. Phím ánh xạ chọn giá trị được định dạng từ ánh xạ. 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'] --> 6248
Trong trường hợp này, không có trình xá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'] --> 61400 nào có thể xuất hiện ở định dạng [vì chúng yêu cầu danh sách tham số tuần tự]
Các ký tự cờ chuyển đổi là
Lá cờ
Nghĩa
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62494
Việc chuyển đổi giá trị sẽ sử dụng “hình thức thay thế” [được định nghĩa bên dưới]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62477
Chuyển đổi sẽ được đệm bằng 0 cho các giá trị 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'] --> 62479
Giá trị chuyển đổi được điều chỉnh trái [ghi đè chuyển đổ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'] --> 62477 nếu cả hai được cung 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'] --> 62498
[khoảng trắng] Nên để trống trước số dương [hoặc chuỗi trống] được tạo bởi chuyển đổi đã ký
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62478
Một ký tự dấ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'] --> 62478 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'] --> 62479] sẽ đứng trước chuyển đổi [ghi đè cờ “dấu cách”]
Có thể có công cụ sửa đổi độ 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'] --> 62802,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62803 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'] --> 62804], nhưng bị bỏ qua vì nó không cần thiết cho Python – vì vậy 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'] --> 62805 giống hệ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'] --> 62806
Các loại chuyển đổi là
chuyển đổi
Nghĩa
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'] --> 62807
Số thập phân có dấ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'] --> 62808
Số thập phân có dấ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'] --> 62809
Giá trị bát phân đã ký
[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'] --> 62810
Loại lỗi thời – nó giống hệ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'] --> 62807
[số 8]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62812
Đã ký thập lục phân [chữ thường]
[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'] --> 62813
Đã ký thập lục phân [chữ hoa]
[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'] --> 62814
Định dạng số mũ dấu phẩy động [chữ thường]
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62815
Định dạng số mũ dấu phẩy động [chữ hoa]
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62816
Định dạng thập phân dấu phẩy động
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62817
Định dạng thập phân dấu phẩy động
[3]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62818
Định dạng dấu phẩy động. Sử dụng định dạng số mũ chữ thường nếu số mũ nhỏ hơn -4 hoặc không nhỏ hơn độ chính xác, nếu không thì định dạng thập phân
[4]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62819
Định dạng dấu phẩy động. Sử dụng định dạng số mũ viết hoa nếu số mũ nhỏ hơn -4 hoặc không nhỏ hơn độ chính xác, nếu không thì định dạng thập phân
[4]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62820
Byte đơn [chấp nhận đối tượng số nguyên hoặc byte đơn]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6022
Byte [bất kỳ đối tượng nào theo sau hoặc có
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6023]
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62823
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62823 là bí danh của
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6022 và chỉ nên được sử dụng cho cơ sở mã Python2/3
[6]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62825
Byte [chuyển đổi bất kỳ đối tượng Python nào 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'] --> 6028]
[5]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62821
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62821 là bí danh của
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62825 và chỉ nên được sử dụng cho cơ sở mã Python2/3
[7]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62487
Không có đối số nào được chuyển đổi, dẫn đến ký 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'] --> 62487 trong kết quả
ghi chú
Dạng thay thế làm cho một bộ xác định bát phân hàng đầ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
2829] được chèn vào trước chữ số đầu tiênDạng thay thế làm cho một số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2830 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
2831 đứng đầu [tùy thuộc vào việc sử dụng định dạ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
2812 haydef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2813] trước chữ số đầu tiênDạng thay thế khiến kết quả luôn chứa dấu thập phân, ngay cả khi không có chữ số nào theo sau nó
Độ chính xác xác định số chữ số sau dấu thập phân và mặc định là 6
Dạng thay thế làm cho kết quả luôn chứa dấu thập phân và các số 0 ở cuối không bị xóa như cách khác
Độ chính xác xác định số chữ số có nghĩa trước và sau dấu thập phân và mặc định là 6
Nếu độ chính xá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'] --> 6
2834, đầu ra bị cắt bớt thành ký 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
2834def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
041 không được dùng nữa, nhưng sẽ không bị xóa trong 3. sê-ri xdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
042 không được dùng nữa, nhưng sẽ không bị xóa trong 3. sê-ri xXem PEP 237
Ghi chú
Phiên bản bytearray của phương pháp này không hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện
Xem thêm
PEP 461 - Thêm % định dạng vào byte và bytearray
Mới trong phiên bản 3. 5
Lượt xem bộ nhớ
các đối tượng cho phép mã Python truy cập dữ liệu bên trong của một đối tượng hỗ trợ mà không cần sao chép
lớp chế độ xem bộ nhớ[đối tượng]Tạo một đối tượng tham chiếu đó. đối tượng phải hỗ trợ giao thức đệm. Các đối tượng tích hợp hỗ trợ giao thức đệm bao gồm và
A có khái niệm về một phần tử, là đơn vị bộ nhớ nguyên tử được xử lý bởi đối tượng gốc. Đối với nhiều loại đơn giản như and , một phần tử là một byte đơn, nhưng các loại khác chẳng hạn như có thể có các phần tử lớn hơn
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6051 bằng với chiều dài của. 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'] --> 6053, độ dài là 1. Nếu
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6054, độ dài bằng số phần tử trong khung nhìn. Đối với các kích thước cao hơn, độ dài bằng với độ dài của biểu diễn danh sách lồng nhau của chế độ xem. Thuộc tính sẽ cung cấp cho bạn số byte trong một phần tử
A hỗ trợ cắt và lập chỉ mục để hiển thị dữ liệu của nó. Cắt một chiều sẽ dẫn đến một chế độ xem phụ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6249
Nếu là một trong những công cụ xác định định dạng gốc từ mô-đun, thì việc lập chỉ mục với một số nguyên hoặc một bộ số nguyên cũng được hỗ trợ và trả về một phần tử với loại chính xác. Các lần xem bộ nhớ một chiều có thể được lập chỉ mục bằng một số nguyên hoặc một bộ một số nguyên. Các lần xem bộ nhớ đa chiều có thể được lập chỉ mục với các bộ số nguyên chính xác ndim trong đó ndim là số thứ nguyên. Các lần xem bộ nhớ không chiều có thể được lập chỉ mục với bộ dữ liệu trống
Đây là một ví dụ với định dạng không phải byte
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6280
Nếu đối tượng bên dưới có thể ghi được, chế độ xem bộ nhớ hỗ trợ gán lát cắt một chiều. Thay đổi kích thước không được phép
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6281
Chế độ xem bộ nhớ một chiều của các loại có thể băm [chỉ đọc] với định dạng 'B', 'b' hoặc 'c' cũng có thể băm được. Hàm băm được định nghĩa là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6059
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6282
Đã thay đổi trong phiên bản 3. 3. Giờ đây, các lần xem bộ nhớ một chiều có thể được cắt lát. Chế độ xem bộ nhớ một chiều với các định dạng 'B', 'b' hoặc 'c' hiện có thể băm được.
Đã thay đổi trong phiên bản 3. 4. memoryview hiện được đăng ký tự động với
Đã thay đổi trong phiên bản 3. 5. lượt xem bộ nhớ hiện có thể được lập chỉ mục với bộ số nguyên.
có một số phương pháp
__eq__[nhà xuất khẩu]Chế độ xem bộ nhớ và trình xuất PEP 3118 bằng nhau nếu hình dạng của chúng tương đương nhau và nếu tất cả các giá trị tương ứng đều bằng nhau khi mã định dạng tương ứng của toán hạng được diễn giải bằng cú pháp
Đối với tập hợp con của các chuỗi định dạng hiện được hỗ trợ bởi ,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6065 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'] --> 6066 bằng nhau nếu
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6067
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6283
Nếu một trong hai chuỗi định dạng không được mô-đun hỗ trợ, thì các đối tượng sẽ luôn so sánh là không bằng nhau [ngay cả khi các chuỗi định dạng và nội dung bộ đệm giống hệt nhau]
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6284
Lưu ý rằng, như với các số dấu phẩy động,
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6069 không ngụ ý
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6070 đối với các đối tượng memoryview
Đã thay đổi trong phiên bản 3. 3. Các phiên bản trước so sánh bộ nhớ thô bất kể định dạng mục và cấu trúc mảng logic.
tobyte[thứ tự='C' '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6 285Đối với các mảng không liền kề, kết quả bằng với biểu diễn danh sách phẳng với tất cả các phần tử được chuyển đổi thành byte. hỗ trợ tất cả các chuỗi định dạng, kể cả những chuỗi không có trong cú pháp mô-đun
Mới trong phiên bản 3. 8. thứ tự có thể là {‘C’, ‘F’, ‘A’}. Khi thứ tự là 'C' hoặc 'F', dữ liệu của mảng ban đầu được chuyển thành thứ tự C hoặc Fortran. Đối với các chế độ xem liền kề, 'A' trả về một bản sao chính xác của bộ nhớ vật lý. Đặc biệt, thứ tự Fortran trong bộ nhớ được giữ nguyên. Đối với các chế độ xem không liền kề, dữ liệu được chuyển đổi thành C trước. order=None giống với order=’C’.
hex[[sep[, bytes_per_sep]]]Trả về một đối tượng chuỗi chứa hai chữ số thập lục phân cho mỗi byte trong bộ đệm
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6286
Mới trong phiên bản 3. 5
Đã thay đổi trong phiên bản 3. 8. Tương tự như , giờ đây hỗ trợ các tham số sep và bytes_per_sep tùy chọn để chèn dấu phân cách giữa các byte trong đầu ra hex.
tolist[]Trả về dữ liệu trong bộ đệm dưới dạng danh sách các phầ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'] --> 6287
Đã thay đổi trong phiên bản 3. 3. hiện hỗ trợ tất cả các định dạng gốc ký tự đơn trong cú pháp mô-đun cũng như các biểu diễn đa chiều.
chỉ đọc[]Trả về phiên bản chỉ đọc của đối tượng memoryview. Đối tượng memoryview ban đầu không thay đổi
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6288
Mới trong phiên bản 3. 8
phát hành[]Giải phóng bộ đệm cơ bản được hiển thị bởi đối tượng memoryview. Nhiều đối tượng thực hiện các hành động đặc biệt khi một chế độ xem được giữ trên chúng [ví dụ: chế độ xem sẽ tạm thời cấm thay đổi kích thước];
Sau khi phương thức này được gọi, bất kỳ thao tác tiếp theo nào trên chế độ xem đều tăng a [ngoại trừ chính nó có thể được gọi nhiều lần]
def bit_length[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
Giao thức quản lý bối cảnh có thể được sử dụng cho hiệu ứng tương tự, sử dụng câu lệnh
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6081
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6330
Mới trong phiên bản 3. 2
truyền[định dạng[ , shape]]Truyền chế độ xem bộ nhớ sang định dạng hoặc hình dạng mới. hình dạng mặc định là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6082, có nghĩa là chế độ xem kết quả sẽ là một chiều. Giá trị trả về là một bộ nhớ mới, nhưng bản thân bộ đệm không được sao chép. Các phôi được hỗ trợ là 1D -> C- và C-tiếp giáp -> 1D
Định dạng đích được giới hạn ở định dạng gốc một phần tử theo cú pháp. Một trong các định dạng phải là định dạng byte ['B', 'b' hoặc 'c']. Độ dài byte của kết quả phải giống với độ dài ban đầu
Truyền 1D/dài thành 1D/byte không dấu
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6331
Truyền 1D/byte không dấu thành 1D/char
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6332
Truyền 1D/byte thành 3D/int thành 1D/char đã ký
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6333
Truyền 1D/dài không dấu thành 2D/dài không dấ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'] --> 6334
Mới trong phiên bản 3. 3
Đã thay đổi trong phiên bản 3. 5. Định dạng nguồn không còn bị hạn chế khi truyền sang chế độ xem byte.
Ngoài ra còn có một số thuộc tính chỉ đọc có sẵn
đối tượngĐối tượng cơ bản của memoryview
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6335
Mới trong phiên bản 3. 3
nbytedef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6084. Đây là lượng không gian tính bằng byte mà mảng sẽ sử dụng trong biểu diễn liền kề. Nó không nhất thiết phải bằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6085
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6336
mảng nhiều chiề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'] --> 6337
Mới trong phiên bản 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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6338
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. sải bước
Một bộ số nguyên có độ dài đưa ra kích thước theo byte để truy cập từng phần tử cho từng chiều của mảng
Đã thay đổi trong phiên bản 3. 3. Một bộ trống thay vì
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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-
Mới trong phiên bản 3. 3
f_tiếp giápMột bool cho biết bộ nhớ có phải là Fortran hay không
Mới trong phiên bản 3. 3
tiếp giápMột bool cho biết liệu bộ nhớ có
Mới trong phiên bản 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, 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 pháp 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à
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 62001. Vì nó có thể thay đổi nên nó không có giá trị băm và không thể được sử dụng làm khóa từ điển hoặc làm thành phần của tập hợp khác. Loại là bất biến và — không thể thay đổi nội dung của nó sau khi nó được tạo;
Ví dụ: có thể tạo các tập hợp không trống [không phải tập hợp cố định] bằng cách đặt danh sách các phần tử được phân tách bằng dấu phẩy trong dấu ngoặc nhọn.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 không vào 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
sự khác biệt[*khác]set - other - ...Trả về một tập hợp mới với các phần tử trong tập hợp không có trong các phần tử khác
symmetric_difference[khác]đặt ^ 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
Các phần tử của tập hợp, chẳng hạn như các khóa từ điển, phải là
Các hoạt động nhị phân kết hợp các trường hợp với trả về loại toán hạng đầu tiên. Ví dụ.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
def bit_length[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, và các phương thức 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. ]
Các khóa của từ điển hầu như là các giá trị tùy ý. Các giá trị không phải là , nghĩa là các giá trị chứa danh sách, từ điển hoặc các loại có thể thay đổi khác [được so sánh theo giá trị thay vì theo danh tính đối tượng] có thể không được sử dụng làm khóa. Các giá trị so sánh bằng nhau [chẳng hạn như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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. ________ 0166 hoặc ________ 0167Sử 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í
Để minh họa, tất cả các ví dụ sau đều trả về một từ điển bằng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6173
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6339
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 mượn]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ì 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 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ả về 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 thức 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 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'] --> 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ăngitem[]
Trả lại chế độ xem mới cho các mục của từ điển [
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6197 cặp]. 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
Mới trong phiên bản 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
Mới trong phiên bản 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
Mới trong phiên bản 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
Đã thay đổi trong phiên bản 3. 7. Thứ tự từ điển được đảm bảo là thứ tự chèn. Hành vi này là một chi tiết triển khai của CPython từ 3. 6.
Từ điển và chế độ xem từ điển có thể đảo ngược
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 603
Đã thay đổi trong phiên bản 3. 8. Từ điển hiện có thể đảo ngược.
Xem thêm
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 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. Thứ tự từ điển được đảm bảo là thứ tự chèn.
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ơ bản [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 xác định 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]
Một ví dụ về việc sử dụng chế độ xem từ điển
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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ý bối cảnh này
Một ví dụ về trình quản lý bối cảnh tự trả về là một. Các đối tượng tệp tự trả về từ __enter__[] để cho phép được sử dụng làm biểu thức ngữ cảnh trong câu lệnh
Một ví dụ về trình quản lý bối cảnh trả về một đối tượng liên quan là đối tượng được trả về bởi. Các trình quản lý này đặt ngữ cảnh thập phân đang hoạt động thành một bản sao của ngữ cảnh thập phân ban đầu rồi trả lại bản sao. Điều này cho phép thực hiện các thay đổi đối với ngữ cảnh thập phân hiện tại trong phần thân của câu lệnh mà không ảnh hưởng đến mã bên ngoài câu lệnh
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
Trả về một giá trị thực từ phương thức này sẽ khiến câu lệnh chặn ngoại lệ và tiếp tục thực thi với câu lệnh ngay sau câu lệnh
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6081. 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 thành 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 thông thường. So với chi phí thiết lập bối cảnh thời gian chạy, chi phí hoạt động của một tra cứu từ điển một lớp là không đáng kể
Nhập các loại chú thích — ,
Các loại tích hợp sẵn cốt lõi cho are và
Loại bí danh chung
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 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_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61393 với đối số. 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 được dự định chủ yếu để sử dụng với
Ghi chú
Nói chung, chỉ có thể đăng ký một lớp nếu lớp đó thực hiện phương thức đặc biệt
Một đối tượng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 xác định nhưng không phải là 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ìdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
182 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 bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
2847 cho ], thìdef bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6
1331 cũng sẽ là một thể hiện 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
280, nhưng 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
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
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61468 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
Các hàm dựng sẵn và không chấp nhận các loại
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 cho đối số thứ hai của chúng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 thức của các thùng chứa chung sẽ đưa ra một ngoại lệ để không cho phép các lỗi như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 đối tượng def bit_length[self]:
s = bin[self] # binary representation: bin[-37] --> '-0b100101'
s = s.lstrip['-0b'] # remove leading zeros and minus sign
return len[s] # len['100101'] --> 6
252
Tấ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] của 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
Ghi chú
Một đối tượng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6252 với các tham số có thể không đúng
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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ị logic đúng nếu bí danh đã được giải nén bằng cách sử dụng 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'] --> 61400 [xem ]
Mới trong phiên bản 3. 11
Xem thêm
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ẩnGiới thiệu khả năng tham số hóa các lớp thư viện tiêu chuẩn, miễn là chúng triển khai phương thức lớp đặc biệt
, và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
Mới trong phiên bản 3. 9
Loại liên minh
Một đối tượng kết hợp giữ giá trị của 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'] --> 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
Ghi chú
Phương thức
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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
Xem thêm
PEP 604 – PEP đề xuất cú pháp
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6373 và kiểu Union
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à
def bit_length[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, 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
Chức năng
Các đối tượng hàm được tạo bởi các định nghĩa hàm. Thao tác duy nhất trên một đối tượng hàm là gọi nó.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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]. Khi được gọi, nó sẽ thêm đối số
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6401 vào danh sách đối số. Các phương thức ràng buộc có hai thuộc tính chỉ đọc đặc biệt.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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.
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6419
Đố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
Nó được viết là
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 631
Đối tượng Dấu chấm lửng
Đố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. Nó mô tả các đối tượng khung ngăn xếp, đối tượng truy nguyên và đối tượng lát
Thuộc tính đặc biệt
Việc triển khai thêm một vài thuộc tính chỉ đọc đặc biệt cho một số loại đối tượng, nơi chúng có liên quan. Một số trong số này không được báo cáo bởi chức năng tích hợp
đối tượng. __dict__Từ điển hoặc đối tượng ánh xạ khác được sử dụng để lưu trữ các thuộc tính [có thể ghi] của đối tượng
ví dụ. __class__Lớp mà một thể hiện của lớp thuộc về
lớp. __base__Bộ các lớp cơ sở của một đối tượng lớp
định nghĩa. __name__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
Mới trong phiên bản 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 CPython là một số có độ dài tùy ý được lưu trữ ở dạng nhị phân [thường được gọi là “bignum”]. Không tồn tại thuật toán nào có thể chuyển đổi một chuỗi thành một số nguyên nhị phân hoặc một số nguyên nhị phân thành một chuỗi trong thời gian tuyến tính, trừ khi cơ số là lũy thừa của 2. Ngay cả các thuật toán được biết đến nhiều nhất cho cơ số 10 cũng có độ phức tạp bậc hai. Chuyển đổi một giá trị lớn chẳng hạn như
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6441 có thể mất hơn một giây trên CPU nhanh
Giới hạn kích thước chuyển đổi cung cấp một cách thiết thực để tránh CVE-2020-10735
Giới hạn được áp dụng cho số ký tự chữ số trong chuỗi đầu vào hoặc đầu ra khi sử dụng thuật toán chuyển đổi phi tuyến tính. Dấu gạch dưới và dấu không được tính vào giới hạn
Khi một hoạt động sẽ vượt quá giới hạn, a được nâng lên
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 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 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ả tùy chọn 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 đượ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, giá trị này là ________ 0443 đã được sử dụng trong quá trình khởi tạo
Từ mã, bạn có thể kiểm tra giới hạn hiện tại và đặt giới hạn mới bằng các API này
và là một getter và setter cho giới hạn trên toàn trình thông dịch. Phiên dịch viên phụ có giới hạn riêng của họ
Thông tin về mặc định và tối thiểu có thể được tìm thấy trong
là giới hạn mặc định được biên dịch
là giá trị thấp nhất được chấp nhận cho giới hạn [khác 0 sẽ vô hiệu hóa giới hạn đó]
Mới trong phiên bản 3. 11
thận trọng
Đặt giới hạn thấp có thể dẫn đến sự cố. Mặc dù hiếm gặp, mã tồn tại chứa các hằng số nguyên ở dạng thập phân trong nguồn của chúng vượt quá ngưỡng tối thiểu. Hệ quả của việc đặt giới hạn là mã nguồn Python chứa các số nguyên thập phân dài hơn giới hạn sẽ gặp lỗi trong quá trình phân tích cú pháp, thường là tại thời điểm khởi động hoặc thời điểm nhập hoặc thậm chí tại thời điểm cài đặt - bất kỳ lúc nào bản cập nhật
def bit_length[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 chưa tồn tại cho . Một giải pháp thay thế cho nguồn chứa các hằng số lớn như vậy là chuyển đổi chúng sang dạng thập lục phân
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 61312 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 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
def bit_length[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 mặc định 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
Ví dụ
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 630
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 []
Kết quả là, danh sách
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6488 được coi là bằng với
def bit_length[self]: s = bin[self] # binary representation: bin[-37] --> '-0b100101' s = s.lstrip['-0b'] # remove leading zeros and minus sign return len[s] # len['100101'] --> 6489 và tương tự đối với các bộ dữ liệu
Chúng phải có vì trình phân tích cú pháp không thể cho biết loại toán hạng
4[,,,]Các ký tự viết hoa là những ký tự có thuộc tính danh mục chung là một trong “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