Hướng dẫn bytes data type in python - kiểu dữ liệu byte trong python

chỉ số của x và y

chỉ số của x và y

Phần còn lại của

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

x phủ định

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Notes:

1. Phần còn lại của

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   29

2. x phủ định

3. x Không thay đổi

4. giá trị tuyệt đối hoặc độ lớn của x

x chuyển đổi thành số nguyên

Loại INT thực hiện lớp cơ sở trừu tượng

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Trả về số lượng bit cần thiết để thể hiện số nguyên trong nhị phân, không bao gồm dấu hiệu và số không hàng đầu:

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

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

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

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

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.

Trả về số lượng trong số biểu diễn nhị phân của giá trị tuyệt đối của số nguyên. Điều này còn được gọi là số lượng dân số. Thí dụ:

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

Tương đương với:

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

Mới trong phiên bản 3.1.

Trả về số lượng trong số biểu diễn nhị phân của giá trị tuyệt đối của số nguyên. Điều này còn được gọi là số lượng dân số. Thí dụ:

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

Mới trong phiên bản 3.10.

int.to_bytes (length = 1, byteorder = 'lớn', *, đã ký = false) ¶

Trả về một mảng byte đại diện cho một số nguyên.

Số nguyên được biểu diễn bằng cách sử dụng các byte độ dài và mặc định là 1. Một

b'Python is interesting.'

Tương đương với:

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

Mới trong phiên bản 3.1.

int.bit_count ()Added default argument values for

b'Python is interesting.'

b'Python is interesting.'

Mới trong phiên bản 3.10.

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

int.to_bytes (length = 1, byteorder = 'lớn', *, đã ký = false) ¶bytes-like object or an iterable producing bytes.

Trả về một mảng byte đại diện cho một số nguyên.

Số nguyên được biểu diễn bằng cách sử dụng các byte độ dài và mặc định là 1. Một

b'Python is interesting.'

Tương đương với:

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

Mới trong phiên bản 3.1.

int.bit_count ()Added default argument value for

b'Python is interesting.'

Mới trong phiên bản 3.10.

int.to_bytes (length = 1, byteorder = 'lớn', *, đã ký = false) ¶

Trả về một mảng byte đại diện cho một số nguyên.

Số nguyên được biểu diễn bằng cách sử dụng các byte độ dài và mặc định là 1. Một

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

Đối số đã ký xác định xem hai bổ sung có thể được sử dụng để đại diện cho số nguyên hay không. Nếu được ký là

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

b'Python is interesting.'

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

b'Python is interesting.'

Mới trong phiên bản 3.2.

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

Đã thay đổi trong phiên bản 3.11: Đã thêm các giá trị đối số mặc định cho

b'Python is interesting.'

b'Python is interesting.'

Trả về số nguyên được biểu thị bằng mảng byte đã cho.

Đối số byteorder xác định thứ tự byte được sử dụng để biểu diễn số nguyên và mặc định là

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

Đối số đã ký cho biết liệu hai bổ sung có thể được sử dụng để đại diện cho số nguyên hay không.

Đã thay đổi trong phiên bản 3.11: Đã thêm giá trị đối số mặc định cho

b'Python is interesting.'

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

int.as_integer_ratio () ¶

Lưu ý rằng số mũ được viết theo số thập phân chứ không phải là thập lục phân và nó mang lại sức mạnh cho 2 để nhân hệ số. Ví dụ: chuỗi thập lục phân

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

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

Áp dụng chuyển đổi ngược lại

b'Python is interesting.'

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

Băm các loại số

Đối với các số

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

Chi tiết triển khai CPython: Hiện tại, số nguyên tố được sử dụng là

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

b'Python is interesting.'

Dưới đây là các quy tắc chi tiết:

• Nếu

  b'Python is interesting.'

  62 là một số hợp lý không âm và

  b'Python is interesting.'

  63 không chia hết cho

  b'Python is interesting.'

  55, hãy xác định

  b'Python is interesting.'

  65 là

  b'Python is interesting.'

  66, trong đó

  b'Python is interesting.'

  67 cung cấp nghịch đảo của

  b'Python is interesting.'

  63 modulo

  b'Python is interesting.'

  55.

• Nếu

  b'Python is interesting.'

  62 là một số hợp lý không âm và

  b'Python is interesting.'

  63 là chia hết cho

  b'Python is interesting.'

  55 (nhưng

  b'Python is interesting.'

  73 thì không) thì

  b'Python is interesting.'

  63 không có modulo nghịch đảo

  b'Python is interesting.'

  55 và quy tắc trên không áp dụng; Trong trường hợp này xác định

  b'Python is interesting.'

  65 là giá trị không đổi

  b'Python is interesting.'

  77.

• Nếu

  b'Python is interesting.'

  62 là số hợp lý âm định nghĩa

  b'Python is interesting.'

  65 là

  b'Python is interesting.'

  80. Nếu băm kết quả là

  string = "Python is interesting."
  
  # string with encoding 'utf-8'
  arr = bytes(string, 'utf-8')
  print(arr)

  53, hãy thay thế nó bằng

  b'Python is interesting.'

  82.

• Các giá trị cụ thể

  b'Python is interesting.'

  77 và

  b'Python is interesting.'

  84 đượ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 số

  string = "Python is interesting."
  
  # string with encoding 'utf-8'
  arr = bytes(string, 'utf-8')
  print(arr)

  15

  b'Python is interesting.'

  86, các giá trị băm của các phần thực và tưởng tượng được kết hợp bằng cách tính toán

  b'Python is interesting.'

  87, giảm modulo

  b'Python is interesting.'

  88 để nó nằm trong

  b'Python is interesting.'

  89. Một lần nữa, nếu kết quả là

  string = "Python is interesting."
  
  # string with encoding 'utf-8'
  arr = bytes(string, 'utf-8')
  print(arr)

  53, nó đã thay thế bằng

  b'Python is interesting.'

  82.

Để làm rõ các quy tắc trên, ở đây, một số ví dụ mã Python, 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ợp lý,

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Loại máy phát

Các máy phát điện Python cung cấp một cách thuận tiện để thực hiện giao thức Iterator. Nếu một phương thức đối tượng container

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

Các hoạt động trình 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à bất biến.

size = 5

arr = bytes(size)
print(arr)

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à số nguyên và x là một đối tượng tùy ý đáp ứng bất kỳ loại hạn chế nào và giá trị do s.

Các hoạt động

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

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

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

size = 5

arr = bytes(size)
print(arr)

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

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

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

Trình tự 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 từ vựng bằng cách so sánh các yếu 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 chuỗi phải cùng loại và có cùng độ dài. (Để biết chi tiết đầy đủ, hãy xem so sánh trong tham chiếu ngôn ngữ.)Comparisons in the language reference.)

Chuyển tiếp và đảo ngược các trình lặp qua các chuỗi có thể thay đổi truy cập các giá trị bằng cách sử dụng một chỉ mục. Chỉ số đó sẽ tiếp tục diễu hành về phía trước (hoặc lùi) ngay cả khi chuỗi cơ bản bị đột biến. Trình lặp chỉ chấm dứt khi gặp phải

size = 5

arr = bytes(size)
print(arr)

b'Python is interesting.'

Notes:

1. Mặc dù các hoạt động

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   10 và

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   11 chỉ được sử dụng để kiểm tra ngăn chặn đơn giản trong trường hợp chung, một số trình tự chuyên dụng (như

   size = 5
   
   arr = bytes(size)
   print(arr)

   34,

   size = 5
   
   arr = bytes(size)
   print(arr)

   35 và

   size = 5
   
   arr = bytes(size)
   print(arr)

   36) cũng sử dụng chúng để kiểm tra sau:

2. Các giá trị N nhỏ hơn

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

   54 được coi là

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

   54 (mang lại 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; Chúng được tham chiếu nhiều lần. Điều này thường ám ảnh các lập trình viên Python mới; xem xét:

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   1

   Điều đã xảy ra là

   size = 5
   
   arr = bytes(size)
   print(arr)

   39 là danh sách một phần tử chứa một danh sách trống, vì vậy cả ba yếu tố của

   size = 5
   
   arr = bytes(size)
   print(arr)

   40 đều tham khảo danh sách trống duy nhất này. Sửa đổi bất kỳ yếu tố nào của

   size = 5
   
   arr = bytes(size)
   print(arr)

   41 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ày:

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   2

   Giải thích thêm có sẵn trong mục FAQ Làm cách nào để tạo một danh sách đa chiều ?.How do I create a multidimensional list?.

3. Nếu I hoặc J là âm, chỉ số có liên quan đến phần cuối của chuỗi S:

   size = 5
   
   arr = bytes(size)
   print(arr)

   42 hoặc

   size = 5
   
   arr = bytes(size)
   print(arr)

   43 được thay thế. Nhưng lưu ý rằng

   size = 5
   
   arr = bytes(size)
   print(arr)

   44 vẫn là

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

   54.

4. Các lát của S từ I đến J được định nghĩa là chuỗi các mục có chỉ mục k sao cho

   size = 5
   
   arr = bytes(size)
   print(arr)

   46. Nếu i hoặc j lớn hơn

   size = 5
   
   arr = bytes(size)
   print(arr)

   25, hãy sử dụng

   size = 5
   
   arr = bytes(size)
   print(arr)

   25. Nếu tôi bị bỏ qua hoặc

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

   43, hãy sử dụng

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

   54. Nếu J bị bỏ qua hoặc

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

   43, hãy sử dụng

   size = 5
   
   arr = bytes(size)
   print(arr)

   25. Nếu tôi lớn hơn hoặc bằng J, lát cắt trống.

5. Các lát của S từ I đến J với bước k được định nghĩa là chuỗi các mục có chỉ mục

   size = 5
   
   arr = bytes(size)
   print(arr)

   53 sao cho

   size = 5
   
   arr = bytes(size)
   print(arr)

   54. Nói cách khác, các chỉ số là

   size = 5
   
   arr = bytes(size)
   print(arr)

   55,

   size = 5
   
   arr = bytes(size)
   print(arr)

   56,

   size = 5
   
   arr = bytes(size)
   print(arr)

   57,

   size = 5
   
   arr = bytes(size)
   print(arr)

   58, v.v., dừng lại khi đạt được J (nhưng không bao giờ bao gồm J). Khi K dương tính, tôi và J sẽ giảm xuống còn

   size = 5
   
   arr = bytes(size)
   print(arr)

   25 nếu chúng lớn hơn. Khi K âm, I và J bị giảm xuống còn

   size = 5
   
   arr = bytes(size)
   print(arr)

   60 nếu chúng lớn hơn. Nếu tôi hoặc J bị bỏ qua hoặc

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

   43, chúng sẽ trở thành các giá trị cuối cùng của Google (kết thúc phụ thuộc vào dấu hiệu của K). Lưu ý, K không thể bằng không. Nếu K là

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

   43, nó được đối xử như

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

   67.

6. Các chuỗi bất biến luô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 kết hợp lặp đi lặp lại sẽ có chi phí thời gian chạy bậc hai trong tổng chiều dài trình tự. Để có được chi phí thời gian chạy tuyến tính, bạn phải chuyển sang một trong những lựa chọn thay thế dưới đây:

   • Nếu kết hợp các đối tượng

     size = 5
     
     arr = bytes(size)
     print(arr)

     34, bạn có thể xây dựng danh sách và sử dụng

     size = 5
     
     arr = bytes(size)
     print(arr)

     65 ở cuối hoặc nếu không hãy ghi vào một ví dụ

     size = 5
     
     arr = bytes(size)
     print(arr)

     66 và lấy lại giá trị của nó khi hoàn thành

   • Nếu nối các đối tượng

     size = 5
     
     arr = bytes(size)
     print(arr)

     35, bạn có thể sử dụng tương tự

     size = 5
     
     arr = bytes(size)
     print(arr)

     68 hoặc

     size = 5
     
     arr = bytes(size)
     print(arr)

     69 hoặc bạn có thể thực hiện kết nối tại chỗ với đối tượng

     size = 5
     
     arr = bytes(size)
     print(arr)

     36.

     size = 5
     
     arr = bytes(size)
     print(arr)

     36 Các đối tượng có thể thay đổi và có cơ chế tổng thể hiệu quả

   • Nếu kết hợp các đối tượng

     size = 5
     
     arr = bytes(size)
     print(arr)

     06, hãy mở rộng

     size = 5
     
     arr = bytes(size)
     print(arr)

     05 thay thế

   • Đối với các loại khác, hãy điều tra các tài liệu lớp có liên quan

7. Một số loại trình tự (chẳng hạn như

   size = 5
   
   arr = bytes(size)
   print(arr)

   07) chỉ hỗ trợ các chuỗi vật phẩm tuân theo các mẫu cụ thể và do đó don don hỗ trợ nối tiếp hoặc lặp lại trình tự.

8. size = 5
   
   arr = bytes(size)
   print(arr)

   75 tăng

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   89 khi X không được tìm thấy trong s. Không phải tất cả các triển khai hỗ trợ thông qua các đối số bổ sung i và j. Những đối số này cho phép tìm kiếm hiệu quả các tiểu mục của chuỗi. Truyền các đối số bổ sung gần tương đương với việc sử dụng

   size = 5
   
   arr = bytes(size)
   print(arr)

   77, chỉ không sao chép bất kỳ dữ liệu nào và với chỉ số được trả về liên quan đến việc bắt đầu chuỗi thay vì bắt đầu lát cắt.

Các loại trình tự bất biến Jor

Hoạt động duy nhất mà các loại trình tự bất biến thường thực hiện không được thực hiện bởi các loại chuỗi có thể thay đổi là hỗ trợ cho

size = 5

arr = bytes(size)
print(arr)

Hỗ trợ này cho phép các chuỗi bất biến, chẳng hạn như các trường hợp

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)




print(arr)

Cố gắng băm một chuỗi bất biến chứa các giá trị không thể đo được sẽ dẫn đến

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

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 chuỗi có thể thay đổi.

size = 5

arr = bytes(size)
print(arr)

Trong bảng S là một thể hiện của một loại chuỗi có thể thay đổi, T là bất kỳ đối tượng có thể lặp lại và X là một đối tượng tùy ý đáp ứng bất kỳ loại hạn chế nào và giá trị do S áp đặt (ví dụ,

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

size = 5

arr = bytes(size)
print(arr)

b'\x00\x00\x00\x00\x00'

Notes:

1. T phải có cùng chiều dài với lát cắt mà nó đang thay thế.

2. Đối số tùy chọn I mặc định là

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   53, do đó theo mặc định, mục cuối cùng được xóa và trả về.

3. b'\x00\x00\x00\x00\x00'

   13 tăng

   string = "Python is interesting."
   
   # string with encoding 'utf-8'
   arr = bytes(string, 'utf-8')
   print(arr)

   89 khi X không được tìm thấy trong s.

4. Phương pháp

   b'\x00\x00\x00\x00\x00'

   15 sửa đổi trình tự tại chỗ cho nền kinh tế của không gian khi đảo ngược một chuỗi lớn. Để nhắc nhở người dùng rằng nó hoạt động bằng hiệu ứng phụ, nó không trả về trình tự đảo ngược.

5. b'\x00\x00\x00\x00\x00'

   16 và

   b'\x00\x00\x00\x00\x00'

   17 được bao gồm để thống nhất với các giao diện của các container có thể thay đổi mà không ủng hộ các hoạt động cắt lát (như

   size = 5
   
   arr = bytes(size)
   print(arr)

   80 và

   size = 5
   
   arr = bytes(size)
   print(arr)

   81).

   b'\x00\x00\x00\x00\x00'

   17 không phải là một phần của

   size = 5
   
   arr = bytes(size)
   print(arr)

   84 ABC, nhưng hầu hết các lớp trình tự đột biến cụ thể đều cung cấp nó.

   Mới trong Phiên bản 3.3:

   b'\x00\x00\x00\x00\x00'

   16 và

   b'\x00\x00\x00\x00\x00'

   17.

   b'\x00\x00\x00\x00\x00'

   16 and

   b'\x00\x00\x00\x00\x00'

   17 methods.

6. Giá trị n là một số nguyên hoặc một đối tượng thực hiện

   b'\x00\x00\x00\x00\x00'

   24. Giá trị bằng không và âm của n xóa chuỗi. Các mục trong chuỗi không được sao chép; Chúng được tham chiếu nhiều lần, như được giải thích cho

   size = 5
   
   arr = bytes(size)
   print(arr)

   20 theo các hoạt động trình tự phổ biến.Common Sequence Operations.

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 theo ứng dụng).

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:

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

  61

• Sử dụng dấu ngoặc vuông, tách các vật phẩm với dấu phẩy:

  b'\x00\x00\x00\x00\x00'

  27,

  b'\x00\x00\x00\x00\x00'

  28

• Sử dụng danh sách hiểu biết:

  b'\x00\x00\x00\x00\x00'

  29

• Sử dụng hàm tạo loại:

  b'\x00\x00\x00\x00\x00'

  30 hoặc

  b'\x00\x00\x00\x00\x00'

  31

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 ITBER. Có thể lặp lại có thể là một chuỗi, một thùng chứa hỗ trợ lặp hoặc đối tượng lặp. Nếu có thể là một danh sách, một bản sao được tạo và trả lại, tương tự như

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

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

Nhiều hoạt động khác cũng tạo ra các danh sách, bao gồm cả

b'\x00\x00\x00\x00\x00'

Danh sách thực hiện tất cả các hoạt động trình tự chung và có thể thay đổi. Danh sách cũng cung cấp phương pháp bổ sung sau:common and mutable sequence operations. Lists also provide the following additional method:

Phương pháp này sắp xếp danh sách tại chỗ, chỉ sử dụng so sánh

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

b'\x00\x00\x00\x00\x00'

Khóa chỉ định hàm của một đối số được sử dụng để trích xuất một khóa so sánh từ mỗi phần tử danh sách (ví dụ:

b'\x00\x00\x00\x00\x00'

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

Tiện ích

b'\x00\x00\x00\x00\x00'

Đảo ngược là một giá trị boolean. Nếu được đặt thành

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

Phương pháp này sửa đổi trình tự tại chỗ cho nền kinh tế của không gian khi sắp xếp một chuỗi lớn. Để nhắc nhở người dùng rằng nó hoạt động bằng hiệu ứng phụ, nó không trả về trình tự được sắp xếp (sử dụng

b'\x00\x00\x00\x00\x00'

Phương pháp

b'\x00\x00\x00\x00\x00'

Để sắp xếp các ví dụ và một hướng dẫn sắp xếp ngắn gọn, xem phân loại cách.Sorting HOW TO.

Chi tiết triển khai CPYThon: Trong khi một danh sách đang được sắp xếp, hiệu quả của việc cố gắng đột biến 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 thời gian và tăng

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Bài hát

Các bộ dữ liệu là các trình tự 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 (như 2 bộ phận được sản xuất bởi

b'\x00\x00\x00\x00\x00'

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

Tuples có thể được xây dựng theo một số cách:

• Sử dụng một cặp dấu ngoặc đơn để biểu thị bộ tuple trống:

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

  60

• Sử dụng dấu phẩy theo dõi cho một bộ phim đơn:

  b'\x00\x00\x00\x00\x00'

  52 hoặc

  b'\x00\x00\x00\x00\x00'

  53

• Tách các mục với dấu phẩy:

  b'\x00\x00\x00\x00\x00'

  54 hoặc

  b'\x00\x00\x00\x00\x00'

  5555

• Sử dụng

  b'\x00\x00\x00\x00\x00'

  56 tích hợp:

  b'\x00\x00\x00\x00\x00'

  56 hoặc

  b'\x00\x00\x00\x00\x00'

  58

Hàm tạo xây dựng một tuple có các vật phẩm giống nhau và theo cùng thứ tự với các vật phẩm của ITerable. Có thể lặp lại có thể là một chuỗi, một thùng chứa hỗ trợ lặp hoặc đối tượng lặp. Nếu có thể là một tuple, nó sẽ được trả lại không thay đổi. Ví dụ:

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

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

Lưu ý rằng đó thực sự là dấu phẩy tạo ra một tuple, 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 tuple trống hoặc khi chúng cần thiết để tránh sự mơ hồ của cú pháp. Ví dụ:

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

Tuples thực hiện tất cả các hoạt động trình tự phổ biến.common sequence operations.

Đối với các bộ sưu tập dữ liệu không đồng nhất trong đó quyền truy cập theo tên rõ ràng hơn truy cập theo chỉ mục,

b'\x00\x00\x00\x00\x00'

Các dãy¶

Loại

size = 5

arr = bytes(size)
print(arr)

b'Python is interesting.'

Các đối số cho hàm tạo phạm vi phải là số nguyên (tích hợp

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

b'\x00\x00\x00\x00\x00'

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

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

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Đối với một bước tích cực, nội dung của một phạm vi

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

Đối với một bước âm, nội dung của phạm vi vẫn được xác định bởi công thức

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

Một đối tượng phạm vi sẽ trống nếu

b'\x00\x00\x00\x00\x00'

Phạm vi chứa các giá trị tuyệt đối lớn hơn

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'Python is interesting.'

Ví dụ phạm vi:

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Phạm vi thực hiện tất cả các hoạt động trình tự phổ biến ngoại trừ việc kết hợp và lặp lại (do thực tế là các đối tượng phạm vi chỉ có thể đại diện cho các chuỗi theo mô hình nghiêm ngặt và sự lặp lại và nối thường sẽ vi phạm mô hình đó).common sequence operations except concatenation and repetition (due to the fact that range objects can only represent sequences that follow a strict pattern and repetition and concatenation will usually violate that pattern).

Giá trị của tham số bắt đầu (hoặc

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

Giá trị của tham số dừng

Giá trị của tham số bước (hoặc

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

Ưu điểm của loại

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

Các đối tượng phạm vi thực hiện

size = 5

arr = bytes(size)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Các đối tượng phạm vi thử nghiệm cho sự bình đẳng với

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

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

Đã thay đổi trong phiên bản 3.2: Thực hiện trình tự ABC. Hỗ trợ cắt lát và chỉ số tiêu cực. Kiểm tra

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Đã thay đổi trong phiên bản 3.3: Xác định ‘== và và‘! = Để so sánh các đối tượng phạm vi dựa trên chuỗi các giá trị mà chúng xác định (thay vì so sánh dựa trên nhận dạng đối tượng).Define ‘==’ and ‘!=’ to compare range objects based on the sequence of values they define (instead of comparing based on object identity).

Mới trong phiên bản 3.3: Các thuộc tính

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

b'\x00\x00\x00\x00\x00'

Xem thêm

• Công thức Linspace cho thấy cách thực hiện một phiên bản lười biếng của phạm vi phù hợp cho các ứng dụng điểm nổi.

Phương pháp chuỗi

Các chuỗi thực hiện tất cả các hoạt động trình tự chung, cùng với các phương pháp bổ sung được mô tả dưới đây.common sequence operations, along with the additional methods described below.

Các chuỗi cũng hỗ trợ hai kiểu định dạng chuỗi, một loại cung cấp một mức độ linh hoạt và tùy chỉnh lớn (xem

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Phần dịch vụ xử lý văn bản của thư viện tiêu chuẩn bao gồm một số mô -đun khác cung cấp các tiện ích liên quan đến văn bản khác nhau (bao gồm hỗ trợ biểu thức thông thường trong mô -đun

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

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.

Thay đổi trong phiên bản 3.8: Nhân vật đầu tiên hiện được đưa vào TitleCase thay vì chữ hoa. Điều này có nghĩa là các nhân vật như Digraphs sẽ chỉ có chữ cái đầu tiên được viết hoa, thay vì toàn bộ ký tự.The first character is now put into titlecase rather than uppercase. This means that characters like digraphs will only have their first letter capitalized, instead of the full character.

Trả về một bản sao được giới thiệu của chuỗi. Các chuỗi casefold có thể được sử dụng để kết hợp không đồng ý.

Casfolding tương tự như LowerCasing nhưng tích cực hơn vì nó nhằm loại bỏ tất cả các trường hợp phân biệt trong một chuỗi. Ví dụ, chữ thường của Đức

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Thuật toán Casefold được mô tả trong Phần 3.13 của tiêu chuẩn Unicode.

Mới trong phiên bản 3.3.

Trả về tập trung trong một chuỗi chiều rộng chiều dài. Đệm được thực hiện bằng cách sử dụng fillchar đượ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

size = 5

arr = bytes(size)
print(arr)

Trả về số lần xuất hiện không chồng chéo của phụ con trong phạm vi [bắt đầu, kết thúc]. Đối số tùy chọn bắt đầu và kết thúc được hiểu là trong ký hiệu lát cắt.

Nếu phụ trống, hãy trả về số chuỗi trống giữa các ký tự là độ dài của chuỗi cộng với một chuỗi.

Trả về một phiên bản được mã hóa của chuỗi dưới dạng đối tượng byte. Mã hóa mặc định là

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Theo mặc định, đối số lỗi không được kiểm tra các hiệu suất tốt nhất, nhưng chỉ được sử dụng ở lỗi mã hóa đầu tiên. Kích hoạt chế độ phát triển Python hoặc sử dụng bản dựng gỡ lỗi để kiểm tra lỗi.Python Development Mode, or use a debug build to check errors.

Đã thay đổi trong phiên bản 3.1: Hỗ trợ cho các đối số từ khóa được thêm vào.Support for keyword arguments added.

Đã thay đổi trong phiên bản 3.9: Các lỗi hiện được kiểm tra ở chế độ phát triển và ở chế độ gỡ lỗi.The errors is now checked in development mode and in debug mode.

Trả về

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

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

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 khoảng trắng, 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 mọi ký tự TabSize (mặc định là 8, đưa ra các 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 ký tự theo ký tự. Nếu ký tự là một tab (

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Trả về chỉ số thấp nhất trong chuỗi nơi tìm thấy phụ phụ trong phần

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Ghi chú

Phương pháp

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Thực hiện thao tác định dạng chuỗi. Chuỗi mà phương pháp này được gọi là có thể chứa văn bản theo nghĩa đen hoặc các trường thay thế được phân tách bằng niềng răng

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

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Xem Cú pháp Chuỗi định dạng để biết 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.Format String Syntax for a description of the various formatting options that can be specified in format strings.

Ghi chú

Định dạng một số (

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

b'Python is interesting.'

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Đã thay đổi trong phiên bản 3.7: Khi định dạng một số với loại

b'Python is interesting.'

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

b'Python is interesting.'

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Tương tự như

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

size = 5

arr = bytes(size)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Mới trong phiên bản 3.2.

Giống như

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Trả về

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

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

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

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

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Trả về

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

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

Trả về

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

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

Mới trong phiên bản 3.7.

Trả về

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

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

Trả về

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

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

Trả về

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

Gọi

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Example:

b'Python is interesting.'

Trả về

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

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

Trả về

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

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

Trả về

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

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

Trả về

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

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

Một ký tự là khoảng trắng nếu trong cơ sở dữ liệu ký tự Unicode (xem

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Trả về

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

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

Trả về

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

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

b'Python is interesting.'

Trả về một chuỗi là sự kết hợp của các chuỗi trong Itable. A

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

size = 5

arr = bytes(size)
print(arr)

Trả về chuỗi bên trái chính đáng trong một chuỗi chiều rộng. Đệm được thực hiện bằng cách sử dụng fillchar đượ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

size = 5

arr = bytes(size)
print(arr)

Trả về một bản sao của chuỗi với tất cả các ký tự vỏ 4 được chuyển đổi thành chữ thường.

Thuật toán hạ thấp được sử dụng được mô tả trong Phần 3.13 của tiêu chuẩn Unicode.

Trả về một bản sao của chuỗi với các ký tự hàng đầu bị xóa. Đối số ký tự là một chuỗi chỉ định tập hợp các ký tự sẽ được xóa. Nếu bị bỏ qua hoặc

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

b'Python is interesting.'

Xem

b'\x01\x02\x03\x04\x05'

b'Python is interesting.'

Phương pháp tĩnh này trả về một bảng dịch có thể sử dụng cho

b'\x01\x02\x03\x04\x05'

Nếu chỉ có một đối số, thì đó phải là một bản đồ từ điển unicode (số nguyên) hoặc ký tự (chuỗi có độ dài 1) thành các thứ tự Unicode, chuỗi (có độ dài tùy ý) hoặc

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

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 một vị trí trong y. Nếu có một đối số thứ ba, nó phải là một chuỗi, có các ký tự sẽ được ánh xạ tới

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

Chia 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 phân cách, chính dấu phân cách và phần sau khi phân tách. Nếu không tìm thấy dấu phân cách, hãy trả về 3-tuple chứa chính chuỗi, theo sau là hai chuỗi trống.

Nếu chuỗi bắt đầu với chuỗi tiền tố, hãy trả về

b'\x01\x02\x03\x04\x05'

b'Python is interesting.'

Mới trong phiên bản 3.9.

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ề

b'\x01\x02\x03\x04\x05'

b'Python is interesting.'

Mới trong phiên bản 3.9.

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ề

b'\x01\x02\x03\x04\x05'

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 phần phụ cũ được thay thế bằng mới. Nếu số lượng đối số tùy chọn được đưa ra, chỉ có các lần xuất hiện đầu tiên được thay thế.

Trả về chỉ số cao nhất trong chuỗi nơi tìm thấy phụ phụ, do đó phụ được chứa trong

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Giống như

b'\x01\x02\x03\x04\x05'

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Trả về chuỗi đúng chính đáng trong một chuỗi chiều rộng chiều dài. Đệm được thực hiện bằng cách sử dụng fillchar đượ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

size = 5

arr = bytes(size)
print(arr)

Chia 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 phân cách, chính dấu phân cách và phần sau khi phân tách. Nếu không tìm thấy dấu phân cách, hãy trả về 3-Tuple chứa hai chuỗi trống, theo sau là chuỗi.

Trả về một bản sao của chuỗi với các ký tự dấu vết bị xóa. Đối số ký tự là một chuỗi chỉ định tập hợp các ký tự sẽ được xóa. Nếu bị bỏ qua hoặc

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

b'Python is interesting.'

Xem

b'\x01\x02\x03\x04\x05'

b'Python is interesting.'

Trả về một danh sách các từ trong chuỗi, sử dụng SEP làm chuỗi DELIMITER. Nếu MAXSplit được đưa ra, tại hầu hết các phân tách MaxSplit được thực hiện (do đó, danh sách sẽ có nhiều nhất là các yếu tố

b'\x01\x02\x03\x04\x05'

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Nếu SEP được đưa ra, các phân định liên tiếp không được nhóm lại với nhau và được coi là phân định các chuỗi trống (ví dụ:

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Ví dụ:

b'Python is interesting.'

Nếu SEP không được chỉ định hoặc là

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

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

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

Ví dụ:

b'Python is interesting.'

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

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

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

Str.SplitLines (Keepends = false) ¶

Trả về một danh sách các dòng trong chuỗi, phá vỡ các ranh giới dòng. Phá vỡ dòng không được bao gồm trong danh sách kết quả trừ khi Keepends được đưa ra và đúng.universal newlines.

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Phân tách đoạn văn

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Ví dụ:

size = 5

arr = bytes(size)
print(arr)

Nếu SEP không được chỉ định hoặc là

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

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

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

size = 5

arr = bytes(size)
print(arr)

Str.SplitLines (Keepends = false) ¶

size = 5

arr = bytes(size)
print(arr)

Phương pháp này phân chia trên các ranh giới dòng sau. Cụ thể, các ranh giới là một siêu dòng của Newlines phổ quát.

Sự mô tả

size = 5

arr = bytes(size)
print(arr)

Line Feed

Vận chuyển trở lại

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Ví dụ:

size = 5

arr = bytes(size)
print(arr)

Nếu SEP không được chỉ định hoặc là

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

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

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

size = 5

arr = bytes(size)
print(arr)

Str.SplitLines (Keepends = false) ¶

Trả về một danh sách các dòng trong chuỗi, phá vỡ các ranh giới dòng. Phá vỡ 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ụ thể, các ranh giới là một siêu dòng của Newlines phổ quát.

Sự mô tảmapping or sequence. When indexed by a Unicode ordinal (an integer), the table object can do any of the following: return a Unicode ordinal or a string, to map the character to one or more other characters; return

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

b'\x01\x02\x03\x04\x05'

Bạn có thể sử dụng

b'\x01\x02\x03\x04\x05'

Xem thêm Mô -đun

b'\x01\x02\x03\x04\x05'

Trả về một bản sao của chuỗi với tất cả các ký tự vỏ 4 được chuyển đổi thành chữ hoa. Lưu ý rằng

b'\x01\x02\x03\x04\x05'

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

b'\x01\x02\x03\x04\x05'

Thuật toán từ trên được sử dụng được mô tả trong Phần 3.13 của tiêu chuẩn Unicode.

Trả về một bản sao của chuỗi bên trái chứa đầy ASCII

b'\x01\x02\x03\x04\x05'

size = 5

arr = bytes(size)
print(arr)

Ví dụ:

size = 5

arr = bytes(size)
print(arr)

________ Định dạng chuỗi theo phong cách 638

Ghi chú

Các hoạt động định dạng được mô tả ở đây thể hiện một loạt các 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 các chuỗi chữ được định dạng mới hơn, giao diện

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Các đối tượng chuỗi có một thao tác tích hợp duy nhất: toán tử

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

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 là một đối tượng. 5 Nếu không, các giá trị phải là một tuple với chính xác số lượng mục được chỉ định bởi chuỗi định dạng hoặc một đối tượng ánh xạ duy nhất (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:

1. Ký tự

   b'\x01\x02\x03\x04\x05'

   98, đánh dấu sự khởi đầu của trình xác định.

2. Khóa ánh xạ (tùy chọn), bao gồm một chuỗi các ký tự dấu ngoặc đơn (ví dụ:

   b'\x01\x02\x03\x04\x05'

   99).

3. 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.

4. Chiều rộng trường tối thiểu (tùy chọn). Nếu được chỉ định là

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

   00 (dấu hoa thị), chiều rộng thực tế được đọc từ phần tử tiếp theo của bộ tple trong các giá trị và đối tượng để 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.

5. Độ chính xác (tùy chọn), được đưa ra dưới dạng

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

   01 (dấu chấm) theo sau là độ chính xác. Nếu được chỉ định là

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

   00 (dấu hoa thị), độ chính xác thực tế được đọc từ phần tử tiếp theo của tuple trong các giá trị và giá trị để chuyển đổi xuất hiện sau độ chính xác.

6. Công cụ sửa đổi độ dài (tùy chọn).

7. Loại chuyển đổi.

Khi đối số đúng 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ạ dấu ngoặc đơn vào từ điển đó được chèn ngay sau ký tự

b'\x01\x02\x03\x04\x05'

size = 5

arr = bytes(size)
print(arr)

Trong trường hợp này, không có nhà xác định

size = 5

arr = bytes(size)
print(arr)

Các ký tự cờ chuyển đổi là:

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

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

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

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Một công cụ sửa đổi độ dài (

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

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

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

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

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

Các loại chuyển đổi là:

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

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

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

b'\x01\x02\x03\x04\x05'

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

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

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

Notes:

1. Hình thức thay thế làm cho một bộ xác định octal hàng đầu (

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

   40) được chèn trước chữ số đầu tiên.

2. Hình thức thay thế gây ra

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

   41 hoặc

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

   42 hàng đầu (tùy thuộc vào định dạng

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

   23 hay

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

   24 đã được sử dụng) để được chèn trước chữ số đầu tiên.

3. Hình thức thay thế làm cho kết quả luôn chứa một điểm thập phân, ngay cả khi không có chữ số nào tuân theo nó.

   Độ chính xác xác định số lượng chữ số sau điểm thập phân và mặc định là 6.

4. Hình thức thay thế gây ra kết quả luôn chứa một điểm thập phân và các số 0 không được loại bỏ như chúng sẽ có.

   Độ chính xác xác định số lượng các chữ số đáng kể trước và sau điểm thập phân và mặc định là 6.

5. Nếu độ chính xác là

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

   45, đầu ra bị cắt giảm thành

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

   45 ký tự.

6. Xem PEP 237.PEP 237.

Vì các chuỗi Python có độ dài rõ ràng, các chuyển đổi

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

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

Đã thay đổi trong phiên bản 3.1:

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

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

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

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

Đối tượng byte

Đố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à liên quan chặt chẽ đến các đối tượng chuỗi theo nhiều cách khác.

Đầu tiên, cú pháp cho các chữ cái byte phần lớn giống như đối với các chữ viết, ngoại trừ tiền tố

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

• Trích dẫn đơn:

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

  59

• Báo giá kép:

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

  60

• Triple Trích dẫn:

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

  61,

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

  62

Chỉ các ký tự ASCII được phép trong các chữ cái byte (bất kể mã hóa mã nguồn được khai báo). Bất kỳ giá trị nhị phân nào trên 127 phải được nhập vào các chữ cái bằng cách sử dụng trình tự thoát thích hợp.

Như với các chữ viết, các chữ cái byte cũng có thể sử dụng tiền tố

b'\x00\x00\x00\x00\x00'

Mặc dù các byte theo nghĩa đen và biểu diễn dựa trên văn bản ASCII, các đối tượng byte thực sự hoạt độ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

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

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Ngoài các biểu mẫu theo nghĩa đen, 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 chứa không có độ dài được chỉ định:

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

  66

• Từ một số nguyên của số nguyên:

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

  67

• Sao chép dữ liệu nhị phân hiện có thông qua giao thức bộ đệm:

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

  68

Cũng xem các byte tích hợp.bytes built-in.

Vì 2 chữ số thập lục phân tương ứng chính xác với một byte duy nhất, các số thập lục phân là một định dạng thường được sử dụng để mô tả dữ liệu nhị phân. Theo đó, loại byte có một phương thức lớp bổ sung để đọc dữ liệu ở định dạng đó:

Phương thức lớp

size = 5

arr = bytes(size)
print(arr)

b'\x00\x00\x00\x00\x00'

Đã thay đổi trong phiên bản 3.7:

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

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

Một hàm chuyển đổi ngược tồn tại để biến một đối tượng byte thành đại diện thập lục phân của nó.

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 trường hợp.

b'\x00\x00\x00\x00\x00'

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 của một ký tự duy nhất để đưa vào đầu ra. Theo mặc định, dấu phân cách này sẽ được bao gồm giữa mỗi byte. Một tham số tùy chọn thứ hai byte_per_sep kiểm soát khoảng cách. Các giá trị dương tính vị trí phân tách từ bên phải, các giá trị âm từ bên trái.

b'\x00\x00\x00\x00\x00'

Mới trong phiên bản 3.5.

Đã thay đổi trong phiên bản 3.8:

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

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

Vì các đối tượng byte là chuỗi số nguyên (gần giống với một tuple), đối với đối tượng byte B,

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

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

Việc biểu diễn các đối tượng byte sử dụng định dạng theo nghĩa đen (

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

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

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

Đối tượng bytearray

Các đối tượng

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

Không có cú pháp theo nghĩa đen chuyên dụ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 ví dụ trống:

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

  79

• Tạo một thể hiện không chứa không có độ dài nhất định:

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

  80

• Từ một số nguyên của số nguyên:

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

  81

• Sao chép dữ liệu nhị phân hiện có thông qua giao thức bộ đệm:

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

  82

Vì các đối tượng bytearray có thể thay đổi, chúng hỗ trợ các hoạt động chuỗi có thể thay đổi ngoài các hoạt động byte và bytearray phổ biến được mô tả trong các hoạt động byte và bytearray.mutable sequence operations in addition to the common bytes and bytearray operations described in Bytes and Bytearray Operations.

Cũng xem bytearray tích hợp.bytearray built-in.

Vì 2 chữ số thập lục phân tương ứng chính xác với một byte duy nhất, các số thập lục phân là một định dạng thường được sử dụng để mô tả dữ liệu nhị phân. Theo đó, loại bytearray có một phương thức lớp bổ sung để đọc dữ liệu ở định dạng đó:

Phương thức lớp

size = 5

arr = bytes(size)
print(arr)

b'\x00\x00\x00\x00\x00'

Đã thay đổi trong phiên bản 3.7:

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

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

Một hàm chuyển đổi ngược tồn tại để biến một đối tượng bytearray thành đại diện thập lục phân của nó.

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 trường hợp.

b'\x00\x00\x00\x00\x00'

Mới trong phiên bản 3.5.

Đã thay đổi trong phiên bản 3.8:

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

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

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

Vì các đối tượng byte là chuỗi số nguyên (gần giống với một tuple), đối với đối tượng byte B,

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

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

Việc biểu diễn các đối tượng byte sử dụng định dạng theo nghĩa đen (

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

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

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

Đối tượng bytearray

Các đối tượng

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

classByteArray ([Nguồn [, mã hóa [, lỗi]]])

Không có cú pháp theo nghĩa đen chuyên dụ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:

b'\x00\x00\x00\x00\x00'

and:

b'\x00\x00\x00\x00\x00'

Tạo một ví dụ trống:

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

classByteArray ([Nguồn [, mã hóa [, lỗi]]])

Không có cú pháp theo nghĩa đen chuyên dụ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 ví dụ trống:

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

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

Trả về số lần xuất hiện không chồng chéo của phụ Trại con trong phạm vi [bắt đầu, kết thúc]. Đối số tùy chọn bắt đầu và kết thúc được hiểu là trong ký hiệu lát cắt.

Phần tiếp theo để tìm kiếm có thể là bất kỳ đối tượng giống như byte hoặc một số nguyên trong phạm vi 0 đến 255.bytes-like object or an integer in the range 0 to 255.

Nếu phụ trống, hãy trả về số lượng 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 phạm vi 0 đến 255 là phần sau.Also accept an integer in the range 0 to 255 as the subsequence.

Nếu dữ liệu nhị phân bắt đầu với chuỗi tiền tố, hãy trả về

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

b'\x00\x00\x00\x00\x00'

Tiền tố có thể là bất kỳ đối tượng giống như byte.bytes-like object.

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.

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ề

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

b'\x00\x00\x00\x00\x00'

Hậu tố có thể là bất kỳ đối tượng giống như byte.bytes-like object.

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.

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ề

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

Hậu tố có thể là bất kỳ đối tượng giống như byte.Python Development Mode, or use a debug build to check errors.

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.bytes-like object directly, without needing to make a temporary bytes or bytearray object.

Mới trong phiên bản 3.9.Added support for keyword arguments.

byte.removesuffix (hậu tố, /) ¶ bytearray.removesuffix (hậu tố, /) ¶The errors is now checked in development mode and in debug mode.

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

Hậu tố có thể là bất kỳ đối tượng giống như byte.

byte.decode (mã hóa = 'utf-8', error = 'nghiêm ngặt')bytes-like object.

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Theo mặc định, đối số lỗi không được kiểm tra các hiệu suất tốt nhất, nhưng chỉ được sử dụng ở lỗi giải mã đầu tiên. Kích hoạt chế độ phát triển Python hoặc sử dụng bản dựng gỡ lỗi để kiểm tra lỗi.

Phần tiếp theo để tìm kiếm có thể là bất kỳ đối tượng giống như byte hoặc một số nguyên trong phạm vi 0 đến 255.bytes-like object or an integer in the range 0 to 255.

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.

b'\x00\x00\x00\x00\x00'

Đã thay đổi trong phiên bản 3.3: Cũng chấp nhận một số nguyên trong phạm vi 0 đến 255 là phần sau.Also accept an integer in the range 0 to 255 as the subsequence.

Nếu dữ liệu nhị phân bắt đầu với chuỗi tiền tố, hãy trả về

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

Phần tiếp theo để tìm kiếm có thể là bất kỳ đối tượng giống như byte hoặc một số nguyên trong phạm vi 0 đến 255.bytes-like object or an integer in the range 0 to 255.

Đã thay đổi trong phiên bản 3.3: Cũng chấp nhận một số nguyên trong phạm vi 0 đến 255 là phần sau.Also accept an integer in the range 0 to 255 as the subsequence.

Ghi chúbytes-like objects, including

size = 5

arr = bytes(size)
print(arr)

Mới trong phiên bản 3.9.bytes-like objects and have the same length.

byte.removesuffix (hậu tố, /) ¶ bytearray.removesuffix (hậu tố, /) ¶

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

Hậu tố có thể là bất kỳ đối tượng giống như byte.

Bộ phân cách để tìm kiếm có thể là bất kỳ đối tượng giống như byte.bytes-like object.

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 sau đó được thay thế bằng mới. Nếu số lượng đối số tùy chọn được đưa ra, chỉ có các lần xuất hiện đầu tiên được thay thế.

Phần tiếp theo để tìm kiếm và sự thay thế của nó có thể là bất kỳ đối tượng giống như byte nào.bytes-like object.

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.

Trả về chỉ số cao nhất trong chuỗi nơi tìm thấy phụ con, do đó phụ được chứa trong

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Phần tiếp theo để tìm kiếm có thể là bất kỳ đối tượng giống như byte hoặc một số nguyên trong phạm vi 0 đến 255.bytes-like object or an integer in the range 0 to 255.

Đã thay đổi trong phiên bản 3.3: Cũng chấp nhận một số nguyên trong phạm vi 0 đến 255 là phần sau.Also accept an integer in the range 0 to 255 as the subsequence.

Giống như

b'\x01\x02\x03\x04\x05'

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Phần tiếp theo để tìm kiếm có thể là bất kỳ đối tượng giống như byte hoặc một số nguyên trong phạm vi 0 đến 255.bytes-like object or an integer in the range 0 to 255.

Đã thay đổi trong phiên bản 3.3: Cũng chấp nhận một số nguyên trong phạm vi 0 đến 255 là phần sau.Also accept an integer in the range 0 to 255 as the subsequence.

Giống như

b'\x01\x02\x03\x04\x05'

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

Bộ phân cách để tìm kiếm có thể là bất kỳ đối tượng giống như byte.bytes-like object.

Chia trình tự ở 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 phân cách, chính bộ phân cách hoặc bản sao bytearray của nó và phần sau khi phân tách. Nếu không tìm thấy dấu phân cách, hãy trả về 3-tuple chứa hai byte trống hoặc các đối tượng bytearray, theo sau là một bản sao của chuỗi gốc.

byte.startswith (tiền tố [, start [, end]]) ¶ bytearray.startswith (tiền tố [, start [, end]])bytes-like object.

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

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

Tiền tố (ES) để tìm kiếm có thể là bất kỳ đối tượng giống như byte nào.

byte.translate (bảng, /, xóa = b '') ¶ bytearray.translate (bảng, /, xóa = b '')

Trả về một bản sao của các byte hoặc đối tượng bytearray trong đó tất cả các byte xảy ra trong xóa đối số tùy chọn được xóa và các byte còn lại đã được ánh xạ qua bảng dịch đã cho, phải là đối tượng byte có độ dài 256.

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Bạn có thể sử dụng 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

Đặt đối số bảng thành

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

Các phương pháp sau trên byte và các đối tượng bytearray có các hành vi mặc định giả sử việc 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 truyề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ỗ và thay vào đó tạo ra các đối tượng mớ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.

Trả về chỉ số cao nhất trong chuỗi nơi tìm thấy phụ con, do đó phụ được chứa trong

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

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.

Trả về chỉ số cao nhất trong chuỗi nơi tìm thấy phụ con, do đó phụ được chứa trong

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

string = "Python is interesting."

# string with encoding 'utf-8'
arr = bytes(string, 'utf-8')
print(arr)

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Phần tiếp theo để tìm kiếm có thể là bất kỳ đối tượng giống như byte hoặc một số nguyên trong phạm vi 0 đến 255.bytes-like object. See

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

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

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.

Trả về một bản sao của đối tượng đúng được chứng minh theo một chuỗi chiều dài chiều dài. Đệm được thực hiện bằng cách sử dụng fillbyte được chỉ định (mặc định là không gian ASCII). Đối với các đối tượng

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

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.

Trả về một bản sao của đối tượng đúng được chứng minh theo một chuỗi chiều dài chiều dài. Đệm được thực hiện bằng cách sử dụng fillbyte được chỉ định (mặc định là không gian ASCII). Đối với các đối tượng

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

Chia trình tự nhị phân thành các chuỗi cùng loại, sử dụng SEP làm chuỗi DELIMITER. Nếu MAXSplit được đưa ra, tại hầu hết các phân tách MaxSplit được thực hiện, những cái ngoài cùng bên phải. Nếu SEP không được chỉ định hoặc

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

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

byte.rstrip ([chars]) ¶ bytearray.rstrip ([chars]) ¶bytes-like object. See

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

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

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.

Trả về một bản sao của đối tượng đúng được chứng minh theo một chuỗi chiều dài chiều dài. Đệm được thực hiện bằng cách sử dụng fillbyte được chỉ định (mặc định là không gian ASCII). Đối với các đối tượng

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

byte.rsplit (sep = none, maxsplit = -1) ¶ bytearray.rsplit (sep = none, maxsplit = -1) ¶bytes-like object.

Chia trình tự nhị phân thành các chuỗi cùng loại, sử dụng SEP làm chuỗi DELIMITER. Nếu MAXSplit được đưa ra, tại hầu hết các phân tách MaxSplit được thực hiện, những cái ngoài cùng bên phải. Nếu SEP không được chỉ định hoặc

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

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

byte.rstrip ([chars]) ¶ bytearray.rstrip ([chars]) ¶

Chia trình tự nhị phân thành các chuỗi cùng loại, sử dụng SEP làm chuỗi DELIMITER. Nếu MAXSplit được đưa ra, tại hầu hết các phân tách MaxSplit được thực hiện, những cái ngoài cùng bên phải. Nếu SEP không được chỉ định hoặc

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

b'\x01\x02\x03\x04\x05'

b'\x01\x02\x03\x04\x05'

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Trả về một bản sao của chuỗi với byte byte được chỉ định được xóa. Đối số chars là một chuỗi nhị phân chỉ định tập hợp các giá trị byte sẽ được xóa - tên đề cập đến thực tế phương pháp này thường được sử dụng với các ký tự ASCII. Nếu bị bỏ qua hoặc

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

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Trình tự nhị phân của các giá trị byte để xóa có thể là bất kỳ đối tượng giống như byte nào. Xem

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

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]) ¶

size = 5

arr = bytes(size)
print(arr)

size = 5

arr = bytes(size)
print(arr)

byte.rsplit (sep = none, maxsplit = -1) ¶ bytearray.rsplit (sep = none, maxsplit = -1) ¶

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.

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 không gian ASCII, 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 mọi byte tabsize (mặc định là 8, đưa ra các vị trí tab tại các cột 0, 8, 16, v.v.). Để mở rộng trình tự, cột hiện tại được đặt thành 0 và trình tự được kiểm tra byte bằng byte. Nếu byte là ký tự tab ASCII (

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

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

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.

Trả về

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

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

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

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

Ví dụ:

rList = [1, 2, 3, 4, 5]

arr = bytes(rList)
print(arr)

Trả về

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

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

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

Ví dụ:

b'\x01\x02\x03\x04\x05'

Trả về

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

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

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

byte.isascii () bytearray.isascii () ¶

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

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

Mới trong phiên bản 3.7.

Ví dụ:

b'\x01\x02\x03\x04\x05'

Trả về

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

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

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

Ví dụ:

b'\x01\x02\x03\x04\x05'

byte.isalpha () bytearray.isalpha () ¶

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

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

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

byte.isascii () bytearray.isascii () ¶

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

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

Mới trong phiên bản 3.7.

Ví dụ:

b'\x01\x02\x03\x04\x05'

Trả về

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

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

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

Ví dụ:

b'\x01\x02\x03\x04\x05'

byte.isalpha () bytearray.isalpha () ¶

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

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

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

byte.isascii () bytearray.isascii () ¶

Ví dụ:

b'\x01\x02\x03\x04\x05'

byte.isalpha () bytearray.isalpha () ¶

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.

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

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

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

byte.isascii () bytearray.isascii () ¶universal newlines approach to splitting lines. Line breaks are not included in the resulting list unless keepends is given and true.

Ví dụ:

b'\x01\x02\x03\x04\x05'

byte.isalpha () bytearray.isalpha () ¶

b'\x01\x02\x03\x04\x05'

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

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

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

byte.isascii () bytearray.isascii () ¶

Ví dụ:

b'\x01\x02\x03\x04\x05'

Các ký tự ASCII viết 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') --> 6

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

Không 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') --> 6

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

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.

Trả về một phiên bản tiêu chuẩn của chuỗi nhị phân trong đó các từ bắt đầu bằng ký tự ASCII chữ hoa và các ký tự còn lại là chữ thường. Các giá trị byte không bị bỏ lại không được sửa đổi.

Ví dụ:

b'\x01\x02\x03\x04\x05'

Các ký tự ASCII viết 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') --> 6

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

Thuật toán sử dụng một định nghĩa độc lập ngôn ngữ đơn giản của một từ là các nhóm chữ cái liên tiếp. Định nghĩa hoạt động trong nhiều bối cảnh nhưng nó có nghĩa là các dấu nháy đơn trong các cơn co thắt và sở hữu hình thành ranh giới từ, có thể không phải là kết quả mong muốn:

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

Một cách giải quyết cho dấu nháy đơn có thể được xây dựng bằng cách sử dụng các biểu thức thông thường:

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

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.

Trả về một phiên bản tiêu chuẩn của chuỗi nhị phân trong đó các từ bắt đầu bằng ký tự ASCII chữ hoa và các ký tự còn lại là chữ thường. Các giá trị byte không bị bỏ lại không được sửa đổi.

Ví dụ:

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

Các ký tự ASCII viết 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') --> 6

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

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.

Trả về một phiên bản tiêu chuẩn của chuỗi nhị phân trong đó các từ bắt đầu bằng ký tự ASCII chữ hoa và các ký tự còn lại là chữ thường. Các giá trị byte không bị bỏ lại không được sửa đổi.

Ví dụ:

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

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.title () bytearray.title () ¶

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.title () bytearray.title () ¶

Trả về một phiên bản tiêu chuẩn của chuỗi nhị phân trong đó các từ bắt đầu bằng ký tự ASCII chữ hoa và các ký tự còn lại là chữ thường. Các giá trị byte không bị bỏ lại không được sửa đổi.

Các ký tự ASCII viết 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') --> 6

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

1. Thuật toán sử dụng một định nghĩa độc lập ngôn ngữ đơn giản của một từ là các nhóm chữ cái liên tiếp. Định nghĩa hoạt động trong nhiều bối cảnh nhưng nó có nghĩa là các dấu nháy đơn trong các cơn co thắt và sở hữu hình thành ranh giới từ, có thể không phải là kết quả mong muốn:

2. Một cách giải quyết cho dấu nháy đơn có thể được xây dựng bằng cách sử dụng các biểu thức thông thường:

3. byte.upper () bytearray.upper () ¶

4. Trả về một bản sao của chuỗi với tất cả các ký tự ASCII viết thường được chuyển đổi thành đối tác chữ hoa tương ứng của chúng.

5. byte.zfill (chiều rộng) ¶ bytearray.zfill (chiều rộng) ¶

6. Trả về một bản sao của chuỗi bên trái chứa đầy ASCII

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

   84 chữ số để tạo ra một chuỗi chiều rộng. Một tiền tố dấu hiệu hàng đầu (________ 985/

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

   86) được xử lý bằng cách chèn đệm sau ký tự dấu hiệu chứ không phải trước. Đối với các đối tượng

   size = 5
   
   arr = bytes(size)
   print(arr)

   35, chuỗi gốc đượ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') --> 6
   

   88.

7. ________ 638 Byte theo phong cách