Ánh xạ kiểu dữ liệu trong python

Trong Python, bạn có thể sử dụng hàm map() tích hợp để ánh xạ. Hàm

[1, 4, 9, 16, 25]
2 trả về một đối tượng bản đồ. Đối tượng bản đồ này là kết quả của việc áp dụng một thao tác trên một lần lặp, chẳng hạn như một danh sách. Bạn có thể dễ dàng chuyển đổi đối tượng bản đồ này trở lại danh sách chẳng hạn bằng cách gọi hàm
[1, 4, 9, 16, 25]
4 trên đó

Show

Cú pháp sử dụng hàm

[1, 4, 9, 16, 25]
2

map(operation, iterable)

Trong đó

[1, 4, 9, 16, 25]
6 là một hàm hoặc hàm lambda, tùy theo bạn thích.
[1, 4, 9, 16, 25]
7 là nhóm các mặt hàng mà bạn áp dụng
[1, 4, 9, 16, 25]
6

Ánh xạ danh sách Python

Ánh xạ hoạt động cho bất kỳ lần lặp nào trong Python. Nói cách khác, bạn có thể sử dụng nó trên một danh sách

Ví dụ: hãy bình phương một danh sách các số. Cách tiếp cận này sử dụng hàm lambda làm hàm ánh xạ. Nếu bạn không quen với lambdas, vui lòng xem hướng dẫn này hoặc xem ví dụ tiếp theo không có lambdas

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

squared_nums = map(lambda x: x ** 2, numbers)
print(list(squared_nums))

đầu ra

[1, 4, 9, 16, 25]

Đây là ví dụ tương tự. Lần này, chúng tôi không sử dụng hàm lambda mà thay vào đó là một hàm thông thường

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))

đầu ra

[1, 4, 9, 16, 25]

Đây là kết quả của việc áp dụng hàm

[1, 4, 9, 16, 25]
9 cho từng phần tử của danh sách các số. Lưu ý cách bạn không cần cung cấp cho hình vuông một tham số trong hàm bản đồ. Điều này có thể thực hiện được vì chức năng bản đồ biết bạn đang cố gắng làm gì. Nó tự động chuyển từng phần tử làm đối số cho từng hàm một

Ánh xạ từ điển Python

Bạn cũng có thể ánh xạ từ điển trong Python bằng hàm

[1, 4, 9, 16, 25]
2 tích hợp

Ví dụ: hãy lập bản đồ

map(operation, iterable)
1 sao cho giá trị của các cặp khóa-giá trị trở thành các chuỗi được viết hoa

[1, 4, 9, 16, 25]
4

đầu ra

[1, 4, 9, 16, 25]
5

Có khá nhiều dòng mã, vì vậy hãy làm rõ cách thức hoạt động của nó

  • map(operation, iterable)
    1, là từ điển các cặp khóa-giá trị. Các giá trị không được viết hoa và chúng tôi muốn thay đổi điều đó
  • Hàm
    map(operation, iterable)
    3 lấy một chuỗi và trả về phiên bản viết hoa của nó
  • map(operation, iterable)
    4 là một đối tượng bản đồ. Nó được tạo bằng cách áp dụng hàm
    map(operation, iterable)
    3 cho từng giá trị của từng cặp khóa-giá trị trong
    map(operation, iterable)
    1
  • Để chuyển đổi
    map(operation, iterable)
    4 trở lại từ điển, chúng tôi sử dụng hàm
    map(operation, iterable)
    8 tích hợp

Ánh xạ Python Tuples

Bạn cũng có thể ánh xạ các bộ dữ liệu trong Python. Điều này hoạt động rất giống với việc ánh xạ một danh sách

Ví dụ: hãy tạo một bộ dữ liệu bằng cách viết hoa tên của một bộ dữ liệu khác

[1, 4, 9, 16, 25]
3

đầu ra

[1, 4, 9, 16, 25]
0

Sự kết luận

Trong Python, bạn có thể sử dụng ánh xạ để chuyển đổi một nhóm giá trị thành một nhóm giá trị khác. Để thực hiện việc này, hãy sử dụng chức năng

[1, 4, 9, 16, 25]
2 tích hợp. Hàm này hoạt động bằng cách áp dụng một hàm cho từng phần tử của nhóm giá trị

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 phiên bản bộ sưu tập nhưng

[1, 4, 9, 16, 25]
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 hoàn toàn khi một đối tượng được viết bởi hàm

[1, 4, 9, 16, 25]
634

Kiểm tra giá trị thực¶

Bất kỳ đối tượng nào cũng có thể được kiểm tra giá trị thực, để sử dụng trong điều kiện

[1, 4, 9, 16, 25]
635 hoặc
[1, 4, 9, 16, 25]
636 hoặc dưới dạng toán hạng của các phép toán Boolean bên dưới

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

[1, 4, 9, 16, 25]
637 trả về
[1, 4, 9, 16, 25]
638 hoặc phương thức
[1, 4, 9, 16, 25]
639 trả về 0 khi được gọi với đối tượng. 1 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.

    [1, 4, 9, 16, 25]
    631 và
    [1, 4, 9, 16, 25]
    638

  • số không của bất kỳ loại số nào. ________ 2642, ________ 2643, ________ 2644, ________ 2645, ________ 2646

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

    [1, 4, 9, 16, 25]
    647,
    [1, 4, 9, 16, 25]
    648, ________ 2649, ________ 2650, ________ 2651, ________ 2652

Các hoạt động và hàm tích hợp có kết quả Boolean luôn trả về

[1, 4, 9, 16, 25]
642 hoặc
[1, 4, 9, 16, 25]
638 cho giá trị sai và
[1, 4, 9, 16, 25]
655 hoặc
[1, 4, 9, 16, 25]
656 cho giá trị đúng, trừ khi có quy định khác. (Ngoại lệ quan trọng. các phép toán Boolean
[1, 4, 9, 16, 25]
657 và
[1, 4, 9, 16, 25]
658 luôn trả về một trong các toán hạng của chúng. )

Phép toán Boolean — [1, 4, 9, 16, 25]658, [1, 4, 9, 16, 25]657, [1, 4, 9, 16, 25]661¶

Đâ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ú

[1, 4, 9, 16, 25]
662

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

(1)

[1, 4, 9, 16, 25]
663

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

(2)

[1, 4, 9, 16, 25]
664

nếu x sai thì

[1, 4, 9, 16, 25]
656, ngược lại thì
[1, 4, 9, 16, 25]
638

(3)

ghi chú

  1. Đâ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

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

  3. [1, 4, 9, 16, 25]
    661 có mức ưu tiên thấp hơn so với các toán tử không phải Boolean, vì vậy,
    [1, 4, 9, 16, 25]
    668 được hiểu là
    [1, 4, 9, 16, 25]
    669 và
    [1, 4, 9, 16, 25]
    670 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

[1, 4, 9, 16, 25]
674

hoàn toàn ít hơn

[1, 4, 9, 16, 25]
675

nhỏ hơn hoặc bằng

[1, 4, 9, 16, 25]
676

tuyệt đối lớn hơn

[1, 4, 9, 16, 25]
677

lớn hơn hoặc bằng

[1, 4, 9, 16, 25]
678

bình đẳng

[1, 4, 9, 16, 25]
679

không công bằng

[1, 4, 9, 16, 25]
680

nhận dạng đối tượng

[1, 4, 9, 16, 25]
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ử

[1, 4, 9, 16, 25]
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
[1, 4, 9, 16, 25]
680. Các toán tử
[1, 4, 9, 16, 25]
674,
[1, 4, 9, 16, 25]
675,
[1, 4, 9, 16, 25]
676 và
[1, 4, 9, 16, 25]
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

[1, 4, 9, 16, 25]
689

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

[1, 4, 9, 16, 25]
690,
[1, 4, 9, 16, 25]
691,
[1, 4, 9, 16, 25]
692 và
[1, 4, 9, 16, 25]
693 (nói chung,
[1, 4, 9, 16, 25]
690 và
[1, 4, 9, 16, 25]
689 là đủ, nếu

Không thể tùy chỉnh hành vi của các toán tử

[1, 4, 9, 16, 25]
680 và
[1, 4, 9, 16, 25]
681;

Hai thao tác khác có cùng mức độ ưu tiên cú pháp,

[1, 4, 9, 16, 25]
698 và
[1, 4, 9, 16, 25]
699, được hỗ trợ bởi các loại có thể lặp lại hoặc triển khai phương thức
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
500.

Các loại số — ________ 9501, ________ 9502, ________ 9503¶

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
505 và
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
506. (Thư viện chuẩn bao gồm các loại số bổ sung
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
507, dành cho số hữu tỉ và
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
508, dành 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. Nối

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
509 hoặc
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
510 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 một toán tử số học nhị phân có các toán hạng thuộc các kiểu số khác nhau, thì toán hạng có loại "hẹp hơn" được mở rộng sang toán hạng kia, trong đó số nguyên hẹp hơn dấu phẩy động, hẹp hơn phức hợp. So sánh giữa các số thuộc các loại khác nhau hoạt động như thể các giá trị chính xác của các số đó đang được so sánh. 2

Các hàm tạo

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
511,
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
512 và
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
513 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 phép toán sau (để biết mức độ ưu tiên của các phép toán, hãy xem Mức độ ưu tiên của toán tử ).

Hoạt động

Kết quả

ghi chú

tài liệu đầy đủ

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
514

tổng của x và y

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
515

sự khác biệt của x và y

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
516

sản phẩm của x và y

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
517

thương của x và y

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
518

thương số sàn của x và y

(1)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
519

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
517

(2)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
521

x phủ định

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
522

x không thay đổi

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
523

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
524

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
525

x chuyển thành số nguyên

(3)(6)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
511

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
527

x được chuyển đổi thành dấu phẩy động

(4)(6)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
512

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
529

số phức có phần thực là phần ảo. tôi mặc định là không

(6)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
513

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
531

liên hợp của số phức c

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
532

cặp

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
533

(2)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
534

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
535

x lũy thừa y

(5)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
536

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
537

x lũy thừa y

(5)

ghi chú

  1. Còn gọi là phép chia số nguyên. Giá trị kết quả là một số nguyên, mặc dù loại kết quả không nhất thiết phải là int. Kết quả luôn được làm tròn về phía âm vô cực.

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    538 là
    [1, 4, 9, 16, 25]
    642,
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    540 là
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    541,
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    542 là
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    541 và
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    544 là
    [1, 4, 9, 16, 25]
    642

  2. Khô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

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    524 nếu thích hợp

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

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

  5. Python định nghĩa

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    549 và
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    550 là
    [1, 4, 9, 16, 25]
    655, như thường thấy đối với các ngôn ngữ lập trình

  6. Các chữ số được chấp nhận bao gồm các chữ số

    [1, 4, 9, 16, 25]
    642 đến
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    553 hoặc bất kỳ mã Unicode tương đương nào (điểm mã với thuộc tính
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    554)

    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

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    554

Tất cả các loại

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
556 (
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501 và
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
502) cũng bao gồm các thao tác sau

Hoạt động

Kết quả

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
559

x bị cắt ngắn thành

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
560

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
561

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
562

lớn nhất

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
560 <= x

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
564

ít nhất

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
560 >= x

Để biết các hoạt động số bổ sung, hãy xem các mô-đun

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
566 và
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
567

Phép toán Bitwise trên các kiểu 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ú

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
571

bitwise hoặc của x và y

(4)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
572

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

(4)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
573

bitwise và của x và y

(4)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
574

x dịch sang trái n bit

(1)(2)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
575

x dịch sang phải n bit

(1)(3)

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
576

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

ghi chú

  1. Số ca âm là bất hợp pháp và làm tăng

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    577

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

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    578

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

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    578

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

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    580 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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
581 lớp cơ sở trừu tượng . 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

[1, 4, 9, 16, 25]
77

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
582 khác 0, thì
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
583 là số nguyên dương duy nhất
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
584 sao cho
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
585. Tương tự, khi
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
523 đủ nhỏ để có logarit được làm tròn chính xác, thì
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
587. Nếu
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
582 bằng 0, thì
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
583 trả về
[1, 4, 9, 16, 25]
642

Tương đương với

[1, 4, 9, 16, 25]
6

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

int. bit_count()

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
5

Tương đương với

[1, 4, 9, 16, 25]
89

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

[1, 4, 9, 16, 25]
90

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
591 được nâng lên nếu số nguyên không thể biểu diễn đượ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à

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
592. Nếu thứ tự byte là
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
592, thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu byteorder là
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
594, thì byte quan trọng nhất nằm ở cuối mảng byte

Đối số đã ký xác định xem phần bù của hai có được sử dụng để biểu diễn số nguyên hay không. Nếu được ký là

[1, 4, 9, 16, 25]
638 và một số nguyên âm được đưa ra, một số
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
591 sẽ tăng lên. Giá trị mặc định cho đã ký là
[1, 4, 9, 16, 25]
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 lỗi

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
591

[1, 4, 9, 16, 25]
99

Tương đương với

[1, 4, 9, 16, 25]
00

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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
599 và
[1, 4, 9, 16, 25]
8900.

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

[1, 4, 9, 16, 25]
03

Các byte đối số phải là một đối tượng giống byte 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à

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
592. Nếu thứ tự byte là
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
592, thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu byteorder là
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
594, 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
[1, 4, 9, 16, 25]
8904 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

[1, 4, 9, 16, 25]
08

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

[1, 4, 9, 16, 25]
8900.

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à

[1, 4, 9, 16, 25]
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 triển khai

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
556 lớp cơ sở trừu tượng . 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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
591 trên vô số và một
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 trên NaN

nổi. is_integer()

Trả về

[1, 4, 9, 16, 25]
656 nếu đối tượng float là hữu hạn với giá trị nguyên và ngược lại là
[1, 4, 9, 16, 25]
638

[1, 4, 9, 16, 25]
16

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

[1, 4, 9, 16, 25]
8912 ở đầu và một
[1, 4, 9, 16, 25]
8913 ở 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

[1, 4, 9, 16, 25]
8914 là một phương thức thể hiện, trong khi
[1, 4, 9, 16, 25]
8915 là một phương thức lớp

Một chuỗi thập lục phân có dạng

[1, 4, 9, 16, 25]
60

trong đó tùy chọn

[1, 4, 9, 16, 25]
8916 có thể bằng một trong hai
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
569 hoặc
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
570,
[1, 4, 9, 16, 25]
8919 và
[1, 4, 9, 16, 25]
8920 là chuỗi các chữ số thập lục phân và
[1, 4, 9, 16, 25]
8921 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
[1, 4, 9, 16, 25]
8914 có thể được 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
[1, 4, 9, 16, 25]
8923 của C hoặc
[1, 4, 9, 16, 25]
8924 của Java được chấp nhận bởi
[1, 4, 9, 16, 25]
8915

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

[1, 4, 9, 16, 25]
8926 đại diện cho số dấu phẩy động
[1, 4, 9, 16, 25]
8927 hoặc
[1, 4, 9, 16, 25]
8928

[1, 4, 9, 16, 25]
61

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

[1, 4, 9, 16, 25]
8928 sẽ cho một chuỗi thập lục phân khác biểu thị cùng một số

[1, 4, 9, 16, 25]
62

Băm các loại số¶

Đối với các số

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
582 và
[1, 4, 9, 16, 25]
8931, có thể thuộc các loại khác nhau, yêu cầu là
[1, 4, 9, 16, 25]
8932 bất cứ khi nào
[1, 4, 9, 16, 25]
8933 (xem tài liệu về phương pháp
[1, 4, 9, 16, 25]
8934 để 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
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501,
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
502,
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
508 và
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
507) 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 phiên bản của
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501 và . Về cơ bản, hàm này được cho bởi modulo rút gọn
[1, 4, 9, 16, 25]
8943 cho số nguyên tố cố định
[1, 4, 9, 16, 25]
8943. Giá trị của
[1, 4, 9, 16, 25]
8943 được cung cấp cho Python dưới dạng thuộc tính
[1, 4, 9, 16, 25]
8946 của
[1, 4, 9, 16, 25]
8947

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

[1, 4, 9, 16, 25]
8948 trên các máy có độ dài C 32 bit và
[1, 4, 9, 16, 25]
8949 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

    [1, 4, 9, 16, 25]
    8950 là một số hữu tỉ không âm và
    [1, 4, 9, 16, 25]
    8951 không chia hết cho
    [1, 4, 9, 16, 25]
    8943, hãy định nghĩa
    [1, 4, 9, 16, 25]
    8953 là
    [1, 4, 9, 16, 25]
    8954, trong đó
    [1, 4, 9, 16, 25]
    8955 cho số nghịch đảo của
    [1, 4, 9, 16, 25]
    8951 theo modulo
    [1, 4, 9, 16, 25]
    8943

  • Nếu

    [1, 4, 9, 16, 25]
    8950 là một số hữu tỉ không âm và
    [1, 4, 9, 16, 25]
    8951 chia hết cho
    [1, 4, 9, 16, 25]
    8943 (nhưng
    [1, 4, 9, 16, 25]
    8961 thì không) thì
    [1, 4, 9, 16, 25]
    8951 không có modulo nghịch đảo
    [1, 4, 9, 16, 25]
    8943 và quy tắc trên không áp dụng;

  • Nếu

    [1, 4, 9, 16, 25]
    8950 là một số hữu tỷ âm, xác định
    [1, 4, 9, 16, 25]
    8953 là
    [1, 4, 9, 16, 25]
    8968. Nếu kết quả băm là
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    541, hãy thay thế nó bằng
    [1, 4, 9, 16, 25]
    8970

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

    [1, 4, 9, 16, 25]
    8965 và
    [1, 4, 9, 16, 25]
    8972 đượ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ố

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    503
    [1, 4, 9, 16, 25]
    8974, 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án _______ 18975, rút ​​gọn modulo ________ 18976 để nó nằm trong ________ 18977. Một lần nữa, nếu kết quả là
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    541, nó sẽ được thay thế bằng
    [1, 4, 9, 16, 25]
    8970

Để 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ỷ,

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
502 hoặc
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
503

[1, 4, 9, 16, 25]
63

Các loại Iterator¶

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ợ có thể lặp lại .

vùng chứa. __iter__()

Trả về một đối tượng iterator . Đố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 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í

[1, 4, 9, 16, 25]
8982 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ả về chính đối tượng iterator . Điều này là cần thiết để cho phép sử dụng cả bộ chứa và bộ lặp với các câu lệnh

[1, 4, 9, 16, 25]
8983 và
[1, 4, 9, 16, 25]
698. Phương thức này tương ứng với vị trí
[1, 4, 9, 16, 25]
8982 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ả về mục tiếp theo từ trình lặp . Nếu không có mục nào khác, hãy tăng ngoại lệ

[1, 4, 9, 16, 25]
8986. Phương thức này tương ứng với vị trí
[1, 4, 9, 16, 25]
8987 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 phương thức

[1, 4, 9, 16, 25]
8988 của iterator tăng
[1, 4, 9, 16, 25]
8986, 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¶

Trình tạo của Python cung cấp một cách thuận tiện để triển khai giao thức trình lặp. Nếu phương thức

[1, 4, 9, 16, 25]
8990 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 lặp (về mặt kỹ thuật, đối tượng trình tạo) cung cấp các phương thức
[1, 4, 9, 16, 25]
8990 và
[1, 4, 9, 16, 25]
8988. Bạn có thể tìm thêm thông tin về trình tạo trong tài liệu về biểu thức năng suất .

Các loại trình tự — [1, 4, 9, 16, 25]8993, [1, 4, 9, 16, 25]8994, [1, 4, 9, 16, 25]8995¶

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ý dữ liệu nhị phânchuỗi văn bản được mô tả .

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.

[1, 4, 9, 16, 25]
8996 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

[1, 4, 9, 16, 25]
698 và
[1, 4, 9, 16, 25]
699 có cùng mức độ ưu tiên như các hoạt động so sánh. Các phép toán
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
569 (nối) và
[1, 4, 9, 16, 25]
9000 (lặp lại) có cùng mức độ ưu tiên như các phép toán số tương ứng. 3

Hoạt động

Kết quả

ghi chú

[1, 4, 9, 16, 25]
9001

[1, 4, 9, 16, 25]
656 nếu một phần tử của s bằng x, ngược lại
[1, 4, 9, 16, 25]
638

(1)

[1, 4, 9, 16, 25]
9004

[1, 4, 9, 16, 25]
638 nếu một phần tử của s bằng x, ngược lại
[1, 4, 9, 16, 25]
656

(1)

[1, 4, 9, 16, 25]
9007

nối của s và t

(6)(7)

[1, 4, 9, 16, 25]
9008 hoặc
[1, 4, 9, 16, 25]
9009

tương đương với việc thêm s vào chính nó n lần

(2)(7)

[1, 4, 9, 16, 25]
9010

mục thứ i của s, gốc 0

(3)

[1, 4, 9, 16, 25]
9011

lát s từ i đến j

(3)(4)

[1, 4, 9, 16, 25]
9012

lát s từ i đến j với bước k

(3)(5)

[1, 4, 9, 16, 25]
9013

chiều dài của s

[1, 4, 9, 16, 25]
9014

mục nhỏ nhất của s

[1, 4, 9, 16, 25]
9015

mục lớn nhất của s

[1, 4, 9, 16, 25]
9016

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)

[1, 4, 9, 16, 25]
9017

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, hãy xem So sánh 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 phải một

[1, 4, 9, 16, 25]
9018 hoặc một
[1, 4, 9, 16, 25]
8986 (hoặc khi chỉ số giảm xuống dưới 0)

ghi chú

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

    [1, 4, 9, 16, 25]
    698 và
    [1, 4, 9, 16, 25]
    699 chỉ được sử dụng cho thử nghiệm 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ư
    [1, 4, 9, 16, 25]
    9022,
    [1, 4, 9, 16, 25]
    9023 và
    [1, 4, 9, 16, 25]
    9024) cũng sử dụng chúng cho thử nghiệm trình tự tiếp theo

    [1, 4, 9, 16, 25]
    64

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

    [1, 4, 9, 16, 25]
    642 được coi là
    [1, 4, 9, 16, 25]
    642 (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;

    [1, 4, 9, 16, 25]
    65

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

    [1, 4, 9, 16, 25]
    9027 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ủa
    [1, 4, 9, 16, 25]
    9028 đề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ủa
    [1, 4, 9, 16, 25]
    9029 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ày

    [1, 4, 9, 16, 25]
    66

    Có thêm giải thích trong mục Câu hỏi thường gặp Làm cách nào để tạo danh sách đa chiều? .

  3. Nếu i hoặc j âm, chỉ số liên quan đến phần cuối của chuỗi s.

    [1, 4, 9, 16, 25]
    9030 hoặc
    [1, 4, 9, 16, 25]
    9031 được thay thế. Nhưng lưu ý rằng
    [1, 4, 9, 16, 25]
    9032 vẫn là
    [1, 4, 9, 16, 25]
    642

  4. Lát của s từ i đến j được định nghĩa là chuỗi các mục có chỉ số k sao cho

    [1, 4, 9, 16, 25]
    9034. Nếu i hoặc j lớn hơn
    [1, 4, 9, 16, 25]
    9013, hãy sử dụng
    [1, 4, 9, 16, 25]
    9013. Nếu tôi bị bỏ qua hoặc
    [1, 4, 9, 16, 25]
    631, hãy sử dụng
    [1, 4, 9, 16, 25]
    642. Nếu j bị bỏ qua hoặc
    [1, 4, 9, 16, 25]
    631, hãy sử dụng
    [1, 4, 9, 16, 25]
    9013. Nếu i lớn hơn hoặc bằng j, lát cắt trống

  5. Lá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ố

    [1, 4, 9, 16, 25]
    9041 sao cho
    [1, 4, 9, 16, 25]
    9042. Nói cách khác, các chỉ số là
    [1, 4, 9, 16, 25]
    9043,
    [1, 4, 9, 16, 25]
    9044,
    [1, 4, 9, 16, 25]
    9045,
    [1, 4, 9, 16, 25]
    9046, 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ống
    [1, 4, 9, 16, 25]
    9013 nếu chúng lớn hơn. Khi k âm, i và j bị giảm xuống
    [1, 4, 9, 16, 25]
    9048 nếu chúng lớn hơn. Nếu i hoặc j bị bỏ qua hoặc
    [1, 4, 9, 16, 25]
    631, 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à
    [1, 4, 9, 16, 25]
    631, nó được xử lý như
    [1, 4, 9, 16, 25]
    655

  6. Nố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

      [1, 4, 9, 16, 25]
      9022, bạn có thể tạo một danh sách và sử dụng
      [1, 4, 9, 16, 25]
      9053 ở cuối hoặc ghi vào một thực thể
      [1, 4, 9, 16, 25]
      9054 và truy xuất giá trị của nó khi hoàn tất

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

      [1, 4, 9, 16, 25]
      9023, bạn có thể sử dụng tương tự
      [1, 4, 9, 16, 25]
      9056 hoặc
      [1, 4, 9, 16, 25]
      9057 hoặc bạn có thể thực hiện nối tại chỗ với một đối tượng
      [1, 4, 9, 16, 25]
      9024. Các đối tượng
      [1, 4, 9, 16, 25]
      9024 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

      [1, 4, 9, 16, 25]
      8994, thay vào đó hãy mở rộng một
      [1, 4, 9, 16, 25]
      8993

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

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

    [1, 4, 9, 16, 25]
    8995) 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ự

  8. [1, 4, 9, 16, 25]
    9063 tăng
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    577 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ụng
    [1, 4, 9, 16, 25]
    9065, 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 kiểu trình tự bất biến¶

Thao tác duy nhất mà các loại trình tự không thể thay đổi thường triển khai mà các loại trình tự có thể thay đổi cũng không triển khai là hỗ trợ cho

[1, 4, 9, 16, 25]
9066 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

[1, 4, 9, 16, 25]
8994, được sử dụng làm khóa
[1, 4, 9, 16, 25]
9068 và được lưu trữ trong phiên bản
[1, 4, 9, 16, 25]
9069 và
[1, 4, 9, 16, 25]
9070

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 ____2688

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.

[1, 4, 9, 16, 25]
9072 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 giới hạn về loại và giá trị do s áp đặt (ví dụ:

[1, 4, 9, 16, 25]
9024 chỉ chấp nhận các số nguyên đáp ứng giới hạn về giá trị
[1, 4, 9, 16, 25]
9074)

Hoạt động

Kết quả

ghi chú

[1, 4, 9, 16, 25]
9075

mục i của s được thay thế bằng x

[1, 4, 9, 16, 25]
9076

lát s từ i đến j được thay thế bằng nội dung của iterable t

[1, 4, 9, 16, 25]
9077

giống như

[1, 4, 9, 16, 25]
9078

[1, 4, 9, 16, 25]
9079

các phần tử của

[1, 4, 9, 16, 25]
9012 được thay thế bằng phần tử của t

(1)

[1, 4, 9, 16, 25]
9081

xóa các phần tử của

[1, 4, 9, 16, 25]
9012 khỏi danh sách

[1, 4, 9, 16, 25]
9083

nối x vào cuối dãy (giống như

[1, 4, 9, 16, 25]
9084)

[1, 4, 9, 16, 25]
9085

xóa tất cả các mục khỏi s (giống như

[1, 4, 9, 16, 25]
9086)

(5)

[1, 4, 9, 16, 25]
9087

tạo một bản sao nông của s (giống như

[1, 4, 9, 16, 25]
9088)

(5)

[1, 4, 9, 16, 25]
9089 hoặc
[1, 4, 9, 16, 25]
9090

kéo dài s với nội dung của t (phần lớn giống như

[1, 4, 9, 16, 25]
9091)

[1, 4, 9, 16, 25]
9092

cập nhật s với nội dung được lặp lại n lần

(6)

[1, 4, 9, 16, 25]
9093

chèn x vào s tại chỉ mục được cung cấp bởi i (giống như

[1, 4, 9, 16, 25]
9094)

[1, 4, 9, 16, 25]
9095 hoặc
[1, 4, 9, 16, 25]
9096

truy xuất mục tại i và cũng xóa mục đó khỏi s

(2)

[1, 4, 9, 16, 25]
9097

xóa mục đầu tiên khỏi s trong đó

[1, 4, 9, 16, 25]
9010 bằng x

(3)

[1, 4, 9, 16, 25]
9099

đảo ngược các mục của s tại chỗ

(4)

ghi chú

  1. t phải có cùng độ 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à

    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    541, do đó, theo mặc định, mục cuối cùng được xóa và trả lại

  3. [1, 4, 9, 16, 25]
    9901 tăng
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    577 khi không tìm thấy x trong s

  4. Phương pháp

    [1, 4, 9, 16, 25]
    9903 sửa đổi trình tự tại chỗ để tiết kiệm không gian khi đảo ngược một trình tự lớn. Để nhắc nhở người dùng rằng nó hoạt động theo tác dụng phụ, nó không trả về trình tự đảo ngược

  5. [1, 4, 9, 16, 25]
    9904 và
    [1, 4, 9, 16, 25]
    9905 được đưa vào để thống nhất với giao diện của các vùng chứa có thể thay đổi không hỗ trợ thao tác cắt (chẳng hạn như
    [1, 4, 9, 16, 25]
    9068 và
    [1, 4, 9, 16, 25]
    9069).
    [1, 4, 9, 16, 25]
    9905 không phải là một phần của
    [1, 4, 9, 16, 25]
    9072 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. ______19904 và phương thức

    [1, 4, 9, 16, 25]
    9905.

  6. Giá trị n là một số nguyên hoặc một đối tượng triển khai

    [1, 4, 9, 16, 25]
    9912. 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; . 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 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.

    [1, 4, 9, 16, 25]
    649

  • Sử dụng dấu ngoặc vuông, phân tách các mục bằng dấu phẩy.

    [1, 4, 9, 16, 25]
    9915,
    [1, 4, 9, 16, 25]
    9916

  • Sử dụng hiểu danh sách.

    [1, 4, 9, 16, 25]
    9917

  • Sử dụng hàm tạo kiểu.

    [1, 4, 9, 16, 25]
    9918 hoặc
    [1, 4, 9, 16, 25]
    9919

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ư

[1, 4, 9, 16, 25]
9920. Ví dụ,
[1, 4, 9, 16, 25]
9921 trả về
[1, 4, 9, 16, 25]
9922 và
[1, 4, 9, 16, 25]
9923 trả về
[1, 4, 9, 16, 25]
9924. 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,
[1, 4, 9, 16, 25]
649

Nhiều thao tác khác cũng tạo danh sách, bao gồm cả danh sách tích hợp sẵn

[1, 4, 9, 16, 25]
9926

Danh sách triển khai tất cả trình tự phổ biếncó thể thay đổi . 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

[1, 4, 9, 16, 25]
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)

[1, 4, 9, 16, 25]
9928 chấp nhận hai đối số chỉ có thể được truyền theo từ khóa ( đối số chỉ có 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ụ:

[1, 4, 9, 16, 25]
9929). 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
[1, 4, 9, 16, 25]
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

[1, 4, 9, 16, 25]
9931 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

[1, 4, 9, 16, 25]
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 hiệu ứng phụ, nó không trả về chuỗi đã sắp xếp (sử dụng

[1, 4, 9, 16, 25]
9926 để 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

[1, 4, 9, 16, 25]
9928 đượ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 ví dụ sắp xếp và hướng dẫn sắp xếp ngắn gọn, hãy xem Sắp xếp CÁCH .

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 một khoảng thời gian và tăng

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 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

Tuples¶

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

[1, 4, 9, 16, 25]
9936 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 thể hiện
[1, 4, 9, 16, 25]
9069 hoặc
[1, 4, 9, 16, 25]
9068)

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.

    [1, 4, 9, 16, 25]
    648

  • Sử dụng dấu phẩy ở cuối cho một tuple đơn lẻ.

    [1, 4, 9, 16, 25]
    9940 hoặc
    [1, 4, 9, 16, 25]
    9941

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

    [1, 4, 9, 16, 25]
    9942 hoặc
    [1, 4, 9, 16, 25]
    9943

  • Sử dụng tích hợp sẵn

    [1, 4, 9, 16, 25]
    9944.
    [1, 4, 9, 16, 25]
    9944 hoặc
    [1, 4, 9, 16, 25]
    9946

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ụ:

[1, 4, 9, 16, 25]
9947 trả về
[1, 4, 9, 16, 25]
9948 và
[1, 4, 9, 16, 25]
9949 trả về
[1, 4, 9, 16, 25]
9950. 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,
[1, 4, 9, 16, 25]
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ụ:

[1, 4, 9, 16, 25]
9952 là một lệnh gọi hàm có ba đối số, trong khi
[1, 4, 9, 16, 25]
9953 là một lệnh gọi hàm có 3 bộ làm đối số duy nhất

Các bộ triển khai tất cả các thao tác trình tự phổ biến .

Đố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,

[1, 4, 9, 16, 25]
9954 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

[1, 4, 9, 16, 25]
8995 đạ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
[1, 4, 9, 16, 25]
8983

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 (có thể là

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501 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
[1, 4, 9, 16, 25]
9912). Nếu đối số bước bị bỏ qua, nó sẽ mặc định là
[1, 4, 9, 16, 25]
655. Nếu đối số bắt đầu bị bỏ qua, nó sẽ mặc định là
[1, 4, 9, 16, 25]
642. Nếu bước bằng 0,
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 đượ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

[1, 4, 9, 16, 25]
9962 được xác định theo công thức
[1, 4, 9, 16, 25]
9963 trong đó
[1, 4, 9, 16, 25]
9964 và
[1, 4, 9, 16, 25]
9965

Đố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

[1, 4, 9, 16, 25]
9963, nhưng các ràng buộc là
[1, 4, 9, 16, 25]
9964 và
[1, 4, 9, 16, 25]
9968

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

[1, 4, 9, 16, 25]
9969 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 các giá trị tuyệt đối lớn hơn

[1, 4, 9, 16, 25]
9970 được cho phép nhưng một số tính năng (chẳng hạn như
[1, 4, 9, 16, 25]
9971) có thể tăng
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
591

Ví dụ phạm vi

[1, 4, 9, 16, 25]
67

Các phạm vi triển khai tất cả các thao tác trình tự phổ biến ngoại trừ nối và lặp lại (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 .

bắt đầu

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

[1, 4, 9, 16, 25]
642 nếu tham số không được cung cấp)

dừng

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

bước

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

[1, 4, 9, 16, 25]
655 nếu tham số không được cung cấp)

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

[1, 4, 9, 16, 25]
8995 so với loại
[1, 4, 9, 16, 25]
8993 hoặc
[1, 4, 9, 16, 25]
8994 thông thường là đối tượng
[1, 4, 9, 16, 25]
8995 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ị
[1, 4, 9, 16, 25]
9979,
[1, 4, 9, 16, 25]
9980 và
[1, 4, 9, 16, 25]
9981

Các đối tượng phạm vi triển khai

[1, 4, 9, 16, 25]
8996 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 Các loại trình tự — danh sách, bộ, phạm vi< . ):

[1, 4, 9, 16, 25]
68

Kiểm tra các đối tượng phạm vi cho bình đẳng với

[1, 4, 9, 16, 25]
678 và
[1, 4, 9, 16, 25]
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
[1, 4, 9, 16, 25]
9979,
[1, 4, 9, 16, 25]
9980 và
[1, 4, 9, 16, 25]
9981 khác nhau, ví dụ:
[1, 4, 9, 16, 25]
9988 hoặc
[1, 4, 9, 16, 25]
9989. )

Đã 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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501 để 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

[1, 4, 9, 16, 25]
9979,
[1, 4, 9, 16, 25]
9980 và
[1, 4, 9, 16, 25]
9981.

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 — [1, 4, 9, 16, 25]9022¶

Dữ liệu văn bản trong Python được xử lý bằng các đối tượng hoặc chuỗi

[1, 4, 9, 16, 25]
9022. Chuỗi là bất biến chuỗi 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.

    [1, 4, 9, 16, 25]
    9996

  • Dấu ngoặc kép.

    [1, 4, 9, 16, 25]
    9997

  • Ba trích dẫn.

    [1, 4, 9, 16, 25]
    9998,
    [1, 4, 9, 16, 25]
    9999

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à,

[1, 4, 9, 16, 25]
0000

Xem Chuỗi ký tự và byte để biết thêm về các dạng khác nhau của chuỗi ký tự, bao gồm các chuỗi thoát được hỗ trợ và

[1, 4, 9, 16, 25]
9962 (“raw” .

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

[1, 4, 9, 16, 25]
9022

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,

[1, 4, 9, 16, 25]
0003

Cũng không có loại chuỗi có thể thay đổi, nhưng có thể sử dụng

[1, 4, 9, 16, 25]
9053 hoặc
[1, 4, 9, 16, 25]
9054 để 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ố

[1, 4, 9, 16, 25]
0006 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ố
[1, 4, 9, 16, 25]
9962.

lớp str(đối tượng='')class str(object=b'', encoding='utf-8', errors='strict')

Trả về phiên bản chuỗi 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

[1, 4, 9, 16, 25]
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ì

[1, 4, 9, 16, 25]
0009 trả về
[1, 4, 9, 16, 25]
0010, 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
[1, 4, 9, 16, 25]
0011, thì
[1, 4, 9, 16, 25]
633 sẽ quay lại trả về
[1, 4, 9, 16, 25]
0013

Nếu có ít nhất một mã hóa hoặc lỗi, đối tượng phải là đối tượng giống byte (e. g.

[1, 4, 9, 16, 25]
9023 hoặc
[1, 4, 9, 16, 25]
9024). Trong trường hợp này, nếu đối tượng là đối tượng
[1, 4, 9, 16, 25]
9023 (hoặc
[1, 4, 9, 16, 25]
9024), thì
[1, 4, 9, 16, 25]
0018 tương đương với
[1, 4, 9, 16, 25]
0019. 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
[1, 4, 9, 16, 25]
0020. Xem Các loại chuỗi nhị phân — byte, bytearray, memoryviewGiao thức bộ đệm để biết .

Truyền đối tượng

[1, 4, 9, 16, 25]
9023 cho
[1, 4, 9, 16, 25]
633 mà không 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
[1, 4, 9, 16, 25]
0023 cho Python). Ví dụ

[1, 4, 9, 16, 25]
69

Để biết thêm thông tin về lớp

[1, 4, 9, 16, 25]
9022 và các phương thức của nó, hãy xem Loại chuỗi văn bản — strString Methods section below. To output formatted strings, see the Chuỗi ký tự được định dạngCú pháp chuỗi định dạng . Ngoài ra, hãy xem phần Dịch vụ xử lý văn bản .

Phương thức chuỗi¶

Chuỗi triển khai tất cả các thao tác trình tự phổ biến , 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 kiểu cung cấp mức độ linh hoạt và tùy chỉnh cao (xem

[1, 4, 9, 16, 25]
0025, Cú pháp định dạng chuỗi và < . Custom String Formatting) and the other based on C
[1, 4, 9, 16, 25]
0026 style formatting that handles a narrower range of types and is slightly harder to use correctly, but is often faster for the cases it can handle (printf-style String Formatting).

Phần Dịch vụ xử lý văn bả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 .

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. Các chuỗi casefolded có thể được sử dụng để so khớp không có vỏ

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

[1, 4, 9, 16, 25]
0028 tương đương với
[1, 4, 9, 16, 25]
0029. Vì nó đã là chữ thường, nên
[1, 4, 9, 16, 25]
0030 sẽ không làm gì đối với
[1, 4, 9, 16, 25]
0028;

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

[1, 4, 9, 16, 25]
9013

str. đế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ả về 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à

[1, 4, 9, 16, 25]
0035. lỗi có thể được đưa ra để thiết lập sơ đồ xử lý lỗi khác. Giá trị mặc định cho các lỗi là
[1, 4, 9, 16, 25]
0036, nghĩa là các lỗi mã hóa sẽ tăng
[1, 4, 9, 16, 25]
0037. Các giá trị có thể khác là
[1, 4, 9, 16, 25]
0038,
[1, 4, 9, 16, 25]
0039,
[1, 4, 9, 16, 25]
0040,
[1, 4, 9, 16, 25]
0041 và bất kỳ tên nào khác được đăng ký qua
[1, 4, 9, 16, 25]
0042, hãy xem phần Trình xử lý lỗi . Để biết danh sách các mã hóa có thể có, hãy xem phần Mã hóa tiêu chuẩn .

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

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

Đã thay đổi trong phiên bản 3. 9. Các lỗi hiện được kiểm tra trong chế độ phát triển và trong chế độ gỡ lỗi .

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

Trả về

[1, 4, 9, 16, 25]
656 nếu chuỗi kết thúc bằng hậu tố đã chỉ định, nếu không thì trả về
[1, 4, 9, 16, 25]
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 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 (

[1, 4, 9, 16, 25]
0045), 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 (
[1, 4, 9, 16, 25]
0046) hoặc trả về (
[1, 4, 9, 16, 25]
0047), 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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
50

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

[1, 4, 9, 16, 25]
0048. 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
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
541 nếu không tìm thấy sub

Ghi chú

Chỉ nên sử dụng phương pháp

[1, 4, 9, 16, 25]
0050 nếu bạn cần biết vị trí của phụ. Để kiểm tra xem sub có phải là chuỗi con hay không, hãy sử dụng toán tử
[1, 4, 9, 16, 25]
698

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
51

str. đị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

[1, 4, 9, 16, 25]
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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
52

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.

Ghi chú

Khi định dạng một số (

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501,
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
502,
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
503,
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
508 và các phân lớp) với loại
[1, 4, 9, 16, 25]
8951 (ví dụ:.
[1, 4, 9, 16, 25]
0058), hàm tạm thời đặt ngôn ngữ
[1, 4, 9, 16, 25]
0059 thành ngôn ngữ
[1, 4, 9, 16, 25]
0060 để giải mã các trường
[1, 4, 9, 16, 25]
0061 và
[1, 4, 9, 16, 25]
0062 của
[1, 4, 9, 16, 25]
0063 nếu chúng không phải ASCII hoặc dài hơn 1 byte và ngôn ngữ
[1, 4, 9, 16, 25]
0060 khác với ngôn ngữ
[1, 4, 9, 16, 25]
0059. 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

[1, 4, 9, 16, 25]
8951, hàm sẽ tạm thời đặt ngôn ngữ
[1, 4, 9, 16, 25]
0059 thành ngôn ngữ
[1, 4, 9, 16, 25]
0060 trong một số trường hợp.

str. format_map(ánh xạ)

Tương tự như

[1, 4, 9, 16, 25]
0069, ngoại trừ việc
[1, 4, 9, 16, 25]
0070 được sử dụng trực tiếp và không được sao chép sang
[1, 4, 9, 16, 25]
9068. Điều này hữu ích nếu ví dụ
[1, 4, 9, 16, 25]
0070 là một lớp con dict

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
53

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

str. chỉ mục(phụ[ , start[, end]])

Giống như

[1, 4, 9, 16, 25]
0050, nhưng tăng
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 khi không tìm thấy chuỗi con

str. isalnum()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
638. Một ký tự
[1, 4, 9, 16, 25]
0077 là chữ và số nếu một trong các giá trị sau trả về
[1, 4, 9, 16, 25]
656.
[1, 4, 9, 16, 25]
0079,
[1, 4, 9, 16, 25]
0080,
[1, 4, 9, 16, 25]
0081 hoặc
[1, 4, 9, 16, 25]
0082

str. isalpha()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
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 Unicode

str. isascii()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
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ề

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
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ề

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
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=Decimal

str. mã định danh()

Trả về

[1, 4, 9, 16, 25]
656 nếu chuỗi là số nhận dạng hợp lệ theo định nghĩa ngôn ngữ, phần Số nhận dạng và từ khóa .

Gọi

[1, 4, 9, 16, 25]
0092 để kiểm tra xem chuỗi
[1, 4, 9, 16, 25]
0093 có phải là mã định danh dành riêng hay không, chẳng hạn như
[1, 4, 9, 16, 25]
0094 và
[1, 4, 9, 16, 25]
0095

Thí dụ

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
54

str. thấp hơn()

Trả về

[1, 4, 9, 16, 25]
656 nếu tất cả các ký tự viết hoa 4 trong chuỗi là chữ thường và có ít nhất một ký tự viết hoa, nếu không thì là
[1, 4, 9, 16, 25]
638

str. số()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
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=Numeric

str. có thể in được()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
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
[1, 4, 9, 16, 25]
632 đượ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
[1, 4, 9, 16, 25]
0303 hoặc
[1, 4, 9, 16, 25]
0304. )

str. không gian()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
638

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

[1, 4, 9, 16, 25]
0307), danh mục chung của nó là
[1, 4, 9, 16, 25]
0308 (“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ố
[1, 4, 9, 16, 25]
0309,
[1, 4, 9, 16, 25]
0310 hoặc
[1, 4, 9, 16, 25]
0311

str. tiêu đề()

Trả về

[1, 4, 9, 16, 25]
656 nếu chuỗi là một chuỗi có tiêu đề và có ít nhất một ký tự, ví dụ: các ký tự chữ hoa chỉ có thể theo sau các ký tự không có chữ hoa và các ký tự chữ thường chỉ theo sau các ký tự có chữ hoa. Trả lại
[1, 4, 9, 16, 25]
638 nếu không

str. ăn tối()

Trả về

[1, 4, 9, 16, 25]
656 nếu tất cả các ký tự viết hoa 4 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ề
[1, 4, 9, 16, 25]
638

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
55

str. 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. Một

[1, 4, 9, 16, 25]
688 sẽ được nâng lên nếu có bất kỳ giá trị không phải chuỗi nào trong iterable, bao gồm các đối tượng
[1, 4, 9, 16, 25]
9023. 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

[1, 4, 9, 16, 25]
9013

str. 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ó vỏ 4 đượ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

[1, 4, 9, 16, 25]
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ố;

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
56

Xem

[1, 4, 9, 16, 25]
0320 để biết 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ụ

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
57

tĩ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 cho

[1, 4, 9, 16, 25]
0321

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

[1, 4, 9, 16, 25]
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, thì đó phải là một chuỗi, các ký tự của chuỗi này sẽ được ánh xạ tới

[1, 4, 9, 16, 25]
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 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-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ề

[1, 4, 9, 16, 25]
0324. Nếu không, hãy trả về một bản sao của chuỗi gốc

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
58

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ề

[1, 4, 9, 16, 25]
0325. Nếu không, hãy trả về một bản sao của chuỗi gốc

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
59

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

str. thay thế( , 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

[1, 4, 9, 16, 25]
0048. 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
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
541 khi thất bại

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

Giống như

[1, 4, 9, 16, 25]
0328 nhưng tăng
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 khi không tìm thấy chuỗi phụ

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

[1, 4, 9, 16, 25]
9013

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

[1, 4, 9, 16, 25]
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,
[1, 4, 9, 16, 25]
0332 hoạt động giống như
[1, 4, 9, 16, 25]
0333 được mô tả chi tiết bên dưới

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

[1, 4, 9, 16, 25]
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ố;

[1, 4, 9, 16, 25]
890

Xem

[1, 4, 9, 16, 25]
0335 để biết phương pháp sẽ xóa một chuỗi hậu tố thay vì tất cả một bộ ký tự. Ví dụ

[1, 4, 9, 16, 25]
891

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

[1, 4, 9, 16, 25]
0336 phần tử). Nếu maxsplit không được chỉ định hoặc
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
541, 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 cung cấp, 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ụ:

[1, 4, 9, 16, 25]
0338 trả về
[1, 4, 9, 16, 25]
0339). Đối số sep có thể bao gồm nhiều ký tự (ví dụ:
[1, 4, 9, 16, 25]
0340 trả về
[1, 4, 9, 16, 25]
0341). Việc tách một chuỗi rỗng bằng một dấu tách được chỉ định sẽ trả về
[1, 4, 9, 16, 25]
0342

Ví dụ

[1, 4, 9, 16, 25]
892

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

[1, 4, 9, 16, 25]
631, một thuật toán phân tách khác sẽ được áp dụng. các khoảng trắng liên tiếp được coi là một dấu phân cách duy nhất và kết quả sẽ không chứa chuỗi trống ở đầu hoặc cuối nếu chuỗi có khoảng trắng ở đầu hoặc cuối. Do đó, việc tách một chuỗi rỗng hoặc một chuỗi chỉ bao gồm khoảng trắng bằng dấu phân cách
[1, 4, 9, 16, 25]
631 sẽ trả về
[1, 4, 9, 16, 25]
649

Ví dụ

[1, 4, 9, 16, 25]
893

str. đườ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ụ thể, các ranh giới là tập hợp siêu của dòng mới chung .

đại diện

Sự mô tả

[1, 4, 9, 16, 25]
0046

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

[1, 4, 9, 16, 25]
0047

Vận chuyển trở lại

[1, 4, 9, 16, 25]
0348

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

[1, 4, 9, 16, 25]
0349 hoặc
[1, 4, 9, 16, 25]
0350

Lập bảng dòng

[1, 4, 9, 16, 25]
0351 hoặc
[1, 4, 9, 16, 25]
0352

Thức ăn dạng

[1, 4, 9, 16, 25]
0353

Trình tách tệp

[1, 4, 9, 16, 25]
0354

Tách nhóm

[1, 4, 9, 16, 25]
0355

Dấu tách bản ghi

[1, 4, 9, 16, 25]
0356

Dòng tiếp theo (Mã kiểm soát C1)

[1, 4, 9, 16, 25]
0357

Dấu phân cách dòng

[1, 4, 9, 16, 25]
0358

Dấu phân cách đoạn văn

Đã thay đổi trong phiên bản 3. 2. ______20349 và

[1, 4, 9, 16, 25]
0351 được thêm vào danh sách ranh giới đường.

Ví dụ

[1, 4, 9, 16, 25]
894

Không giống như

[1, 4, 9, 16, 25]
0333 khi một chuỗi phân cách sep được cung cấp, 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 ở đầu cuối không dẫn đến một dòng thừa

[1, 4, 9, 16, 25]
895

Để so sánh,

[1, 4, 9, 16, 25]
0362 cho

[1, 4, 9, 16, 25]
896

str. startswith(tiền tố[ , start[, end]])

Trả về

[1, 4, 9, 16, 25]
656 nếu chuỗi bắt đầu bằng tiền tố, ngược lại trả về
[1, 4, 9, 16, 25]
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

[1, 4, 9, 16, 25]
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ố;

[1, 4, 9, 16, 25]
897

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ụ

[1, 4, 9, 16, 25]
898

str. 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à

[1, 4, 9, 16, 25]
0366

str. 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ụ

[1, 4, 9, 16, 25]
899

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

[1, 4, 9, 16, 25]
900

Hàm

[1, 4, 9, 16, 25]
0367 không gặp vấn đề 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

[1, 4, 9, 16, 25]
901

str. dịch(bảng)

Trả về 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à đối tượng thực hiện lập chỉ mục thông qua

[1, 4, 9, 16, 25]
0368, thường là ánh xạ hoặc trình tự. 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
[1, 4, 9, 16, 25]
631, to delete the character from the return string; or raise a
[1, 4, 9, 16, 25]
0370 exception, to map the character to itself.

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

[1, 4, 9, 16, 25]
0371 để 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

[1, 4, 9, 16, 25]
0372 để 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ó vỏ 4 được chuyển đổi thành chữ hoa. Lưu ý rằng

[1, 4, 9, 16, 25]
0373 có thể là
[1, 4, 9, 16, 25]
638 nếu
[1, 4, 9, 16, 25]
0093 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 đầy các chữ số ASCII

[1, 4, 9, 16, 25]
0376 để tạo một chuỗi có chiều dài chiều rộng. Tiền tố dấu hiệu hàng đầu (
[1, 4, 9, 16, 25]
0377/
[1, 4, 9, 16, 25]
0378) đượ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
[1, 4, 9, 16, 25]
9013

Ví dụ

[1, 4, 9, 16, 25]
902

Định dạng chuỗi kiểu [1, 4, 9, 16, 25]0026¶

Ghi chú

Các thao tác đị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 chuỗi ký tự được định dạng mới hơn, giao diện

[1, 4, 9, 16, 25]
0025 hoặc chuỗi mẫu . 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ử

[1, 4, 9, 16, 25]
0382 (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
[1, 4, 9, 16, 25]
0383 (trong đó định dạng là một chuỗi), thông số kỹ thuật chuyển đổi của
[1, 4, 9, 16, 25]
0382 ở định dạng được thay thế bằng 0 hoặc nhiều thành phần giá trị. Hiệu quả tương tự như sử dụng
[1, 4, 9, 16, 25]
0385 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. 5 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 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

  1. Ký tự

    [1, 4, 9, 16, 25]
    0386, đánh dấu sự bắt đầu của trình xác định

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

    [1, 4, 9, 16, 25]
    0387)

  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. Độ rộng trường tối thiểu (tùy chọn). Nếu được chỉ định là

    [1, 4, 9, 16, 25]
    0388 (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

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

    [1, 4, 9, 16, 25]
    0389 (dấu chấm) theo sau là độ chính xác. Nếu được chỉ định là
    [1, 4, 9, 16, 25]
    0388 (dấu hoa thị), thì độ chính xác thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu theo giá trị và giá trị cần chuyển đổi xuất hiện sau độ chính xác

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

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

[1, 4, 9, 16, 25]
0386. Phím ánh xạ chọn giá trị được định dạng từ ánh xạ. Ví dụ

[1, 4, 9, 16, 25]
903

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

[1, 4, 9, 16, 25]
9000 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

[1, 4, 9, 16, 25]
0393

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)

[1, 4, 9, 16, 25]
0376

Chuyển đổi sẽ được đệm bằng 0 cho các giá trị số

[1, 4, 9, 16, 25]
0378

Giá trị chuyển đổi được điều chỉnh trái (ghi đè chuyển đổi

[1, 4, 9, 16, 25]
0376 nếu cả hai được cung cấp)

[1, 4, 9, 16, 25]
0397

(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ý

[1, 4, 9, 16, 25]
0377

Một ký tự dấu (

[1, 4, 9, 16, 25]
0377 hoặc
[1, 4, 9, 16, 25]
0378) sẽ đứng trước chuyển đổi (ghi đè cờ “dấu cách”)

Có thể có công cụ sửa đổi độ dài (

[1, 4, 9, 16, 25]
0801,
[1, 4, 9, 16, 25]
0802 hoặc
[1, 4, 9, 16, 25]
0803), nhưng bị bỏ qua vì nó không cần thiết đối với Python – vì vậy e. g.
[1, 4, 9, 16, 25]
0804 giống hệt với
[1, 4, 9, 16, 25]
0805

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

chuyển đổi

Nghĩa

ghi chú

[1, 4, 9, 16, 25]
0806

Số thập phân có dấu

[1, 4, 9, 16, 25]
0807

Số thập phân có dấu

[1, 4, 9, 16, 25]
0808

Giá trị bát phân đã ký

(1)

[1, 4, 9, 16, 25]
0809

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

[1, 4, 9, 16, 25]
0806

(6)

[1, 4, 9, 16, 25]
0811

Đã ký thập lục phân (chữ thường)

(2)

[1, 4, 9, 16, 25]
0812

Đã ký thập lục phân (chữ hoa)

(2)

[1, 4, 9, 16, 25]
0813

Định dạng số mũ dấu phẩy động (chữ thường)

(3)

[1, 4, 9, 16, 25]
0814

Định dạng số mũ dấu phẩy động (chữ hoa)

(3)

[1, 4, 9, 16, 25]
0815

Định dạng thập phân dấu phẩy động

(3)

[1, 4, 9, 16, 25]
0816

Định dạng thập phân dấu phẩy động

(3)

[1, 4, 9, 16, 25]
0817

Đị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)

[1, 4, 9, 16, 25]
0818

Đị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)

[1, 4, 9, 16, 25]
0819

Ký tự đơn (chấp nhận số nguyên hoặc chuỗi ký tự đơn)

[1, 4, 9, 16, 25]
0820

Chuỗi (chuyển đổi bất kỳ đối tượng Python nào bằng cách sử dụng

[1, 4, 9, 16, 25]
632)

(5)

[1, 4, 9, 16, 25]
0822

Chuỗi (chuyển đổi bất kỳ đối tượng Python nào bằng cách sử dụng

[1, 4, 9, 16, 25]
633)

(5)

[1, 4, 9, 16, 25]
0824

Chuỗi (chuyển đổi bất kỳ đối tượng Python nào bằng cách sử dụng

[1, 4, 9, 16, 25]
0825)

(5)

[1, 4, 9, 16, 25]
0386

Không có đối số nào được chuyển đổi, dẫn đến ký tự

[1, 4, 9, 16, 25]
0386 trong kết quả

ghi chú

  1. Dạng thay thế làm cho một bộ xác định bát phân hàng đầu (

    [1, 4, 9, 16, 25]
    0828) được chèn vào trước chữ số đầu tiên

  2. Biểu mẫu thay thế làm cho một

    [1, 4, 9, 16, 25]
    0829 hoặc
    [1, 4, 9, 16, 25]
    0830 ở đầu (tùy thuộc vào việc định dạng
    [1, 4, 9, 16, 25]
    0811 hoặc
    [1, 4, 9, 16, 25]
    0812 được sử dụng) được chèn vào trước chữ số đầu tiên

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

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

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

    [1, 4, 9, 16, 25]
    0833, đầu ra bị cắt bớt thành
    [1, 4, 9, 16, 25]
    0833 ký tự

  6. Xem PEP 237

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

[1, 4, 9, 16, 25]
0835 không cho rằng
[1, 4, 9, 16, 25]
0836 là phần cuối của chuỗi

Đã thay đổi trong phiên bản 3. 1. ______20837 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

[1, 4, 9, 16, 25]
0838.

Các kiểu dãy nhị phân — ________ 19023, ________ 19024, ________ 20841¶

Các loại tích hợp cốt lõi để thao tác dữ liệu nhị phân là

[1, 4, 9, 16, 25]
9023 và
[1, 4, 9, 16, 25]
9024. Chúng được hỗ trợ bởi
[1, 4, 9, 16, 25]
0841 sử dụng giao thức bộ đệm để 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

[1, 4, 9, 16, 25]
0845 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ị động có độ 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ố

[1, 4, 9, 16, 25]
0846 được thêm vào

  • Dấu nháy đơn.

    [1, 4, 9, 16, 25]
    0847

  • Dấu ngoặc kép.

    [1, 4, 9, 16, 25]
    0848

  • Ba trích dẫn. ________ 20849, ________ 20850

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ữ sử dụng trình tự thoát thích hợp

Giống như chuỗi ký tự, ký tự byte cũng có thể sử dụng tiền tố

[1, 4, 9, 16, 25]
9962 để vô hiệu hóa quá trình xử lý chuỗi thoát. Xem Chuỗi và ký tự byte để biết thêm về các dạng ký tự byte 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

[1, 4, 9, 16, 25]
0852 (cố gắng vi phạm hạn chế này sẽ kích hoạt
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577). Điều này được thực hiện có chủ ý để nhấn mạnh rằng trong khi 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, thì điều này thường không xảy ra đối 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 không được lấp đầy có độ dài được chỉ định.

    [1, 4, 9, 16, 25]
    0854

  • Từ một số nguyên có thể lặp lại.

    [1, 4, 9, 16, 25]
    0855

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

    [1, 4, 9, 16, 25]
    0856

Cũng xem byte 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

[1, 4, 9, 16, 25]
9023 này trả về một đối tượng bytes, 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

[1, 4, 9, 16, 25]
904

Đã thay đổi trong phiên bản 3. 7. ______20858 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ụ

[1, 4, 9, 16, 25]
905

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

[1, 4, 9, 16, 25]
906

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

Đã thay đổi trong phiên bản 3. 8. ______20859 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ì các đối tượng byte là các chuỗi số nguyên (tương tự như một tuple), đối với một đối tượng byte b,

[1, 4, 9, 16, 25]
0860 sẽ là một số nguyên, trong khi
[1, 4, 9, 16, 25]
0861 sẽ là một đối tượng byte 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ữ (

[1, 4, 9, 16, 25]
0862) vì nó thường hữu ích hơn e. g.
[1, 4, 9, 16, 25]
0863. 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
[1, 4, 9, 16, 25]
0864

Đối tượng Bytearray¶

Các đối tượng

[1, 4, 9, 16, 25]
9024 là một đối tác có thể thay đổi đối với các đối tượng
[1, 4, 9, 16, 25]
9023

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.

    [1, 4, 9, 16, 25]
    0867

  • Tạo một phiên bản không chứa đầy với độ dài nhất định.

    [1, 4, 9, 16, 25]
    0868

  • Từ một số nguyên có thể lặp lại.

    [1, 4, 9, 16, 25]
    0869

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

    [1, 4, 9, 16, 25]
    0870

Vì các đối tượng mảng phụ có thể thay đổi nên chúng hỗ trợ các thao tác trình tự có thể thay đổi ngoài các hoạt động byte và mảng phụ phổ biến được mô tả trong Bytes and Bytearray Operations.

Ngoài ra, hãy xem bytearray tích hợp sẵn.

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

[1, 4, 9, 16, 25]
9024 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

[1, 4, 9, 16, 25]
907

Đã thay đổi trong phiên bản 3. 7. ______20872 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ụ

[1, 4, 9, 16, 25]
908

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

Đã thay đổi trong phiên bản 3. 8. Tương tự như

[1, 4, 9, 16, 25]
0859,
[1, 4, 9, 16, 25]
0874 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 mảng phụ là dãy số nguyên (gần giống với danh sách), đối với đối tượng mảng phụ b,

[1, 4, 9, 16, 25]
0860 sẽ là số nguyên, trong khi
[1, 4, 9, 16, 25]
0861 sẽ là đối tượng mảng phụ 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ữ (

[1, 4, 9, 16, 25]
0877) vì nó thường hữu ích hơn e. g.
[1, 4, 9, 16, 25]
0878. 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
[1, 4, 9, 16, 25]
0864

Byte và hoạt động Bytearray¶

Cả đối tượng byte và bytearray đều hỗ trợ các thao tác tuần tự phổ biến . Chúng tương tác không chỉ với các toán hạng cùng loại mà còn với bất kỳ đối tượng giống byte nào. 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

[1, 4, 9, 16, 25]
909

[1, 4, 9, 16, 25]
990

Một số hoạt động byte và bytearray giả sử sử dụng đị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ỳ đối tượng giống như byte 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ề

[1, 4, 9, 16, 25]
0880. Mặt khác, trả về một bản sao của dữ liệu nhị phân ban đầu

[1, 4, 9, 16, 25]
991

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

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ề

[1, 4, 9, 16, 25]
0881. Mặt khác, trả về một bản sao của dữ liệu nhị phân ban đầu

[1, 4, 9, 16, 25]
992

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

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ả về một chuỗi được giải mã từ các byte đã cho. Mã hóa mặc định là

[1, 4, 9, 16, 25]
0035. lỗi có thể được đưa ra để thiết lập sơ đồ xử lý lỗi khác. Giá trị mặc định cho các lỗi là
[1, 4, 9, 16, 25]
0036, nghĩa là các lỗi mã hóa sẽ tăng
[1, 4, 9, 16, 25]
0037. Các giá trị có thể khác là
[1, 4, 9, 16, 25]
0038,
[1, 4, 9, 16, 25]
0039 và bất kỳ tên nào khác được đăng ký qua
[1, 4, 9, 16, 25]
0042, xem phần Trình xử lý lỗi . Để biết danh sách các mã hóa có thể có, hãy xem phần Mã hóa tiêu chuẩn .

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

Ghi chú

Truyền đối số mã hóa cho

[1, 4, 9, 16, 25]
9022 cho phép giải mã trực tiếp bất kỳ đối tượng giống byte nào mà không cần tạo một đối tượng byte tạm thời hoặc đối tượng bytearray.

Đã 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. Các lỗi hiện được kiểm tra trong chế độ phát triển và trong chế độ gỡ lỗi .

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

Trả về

[1, 4, 9, 16, 25]
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ề
[1, 4, 9, 16, 25]
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ỳ đối tượng dạng byte .

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

[1, 4, 9, 16, 25]
0048. 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
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
541 nếu không tìm thấy sub

Dãy con cần tìm có thể là bất kỳ đối tượng giống như byte hoặc một số nguyên trong khoảng từ 0 đến 255.

Ghi chú

Chỉ nên sử dụng phương pháp

[1, 4, 9, 16, 25]
0050 nếu bạn cần biết vị trí của phụ. Để kiểm tra xem sub có phải là chuỗi con hay không, hãy sử dụng toán tử
[1, 4, 9, 16, 25]
698

[1, 4, 9, 16, 25]
993

Đã 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]])

Giống như

[1, 4, 9, 16, 25]
0050, nhưng tăng
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 khi không tìm thấy dãy con

Dãy con cần tìm có thể là bất kỳ đối tượng giống như byte 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. Một

[1, 4, 9, 16, 25]
688 sẽ được nâng lên nếu có bất kỳ giá trị nào trong iterable không phải là các đối tượng giống như byte , bao gồm các đối tượng
[1, 4, 9, 16, 25]
9022. 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 cho

[1, 4, 9, 16, 25]
0899 sẽ ánh xạ từng ký tự từ thành ký tự ở cùng một vị trí thành ký tự; . bytes-like objects and have the same length.

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-bộ 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ỳ đối tượng giống như byte .

byte. thay thế( , mới . [, count])bytearray.thay thế( , 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 kiếm và sự thay thế của nó có thể là bất kỳ đối tượng giống như byte .

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 chuỗi con phụ, sao cho phần phụ đó được chứa trong

[1, 4, 9, 16, 25]
0048. 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
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
541 khi thất bại

Dãy con cần tìm có thể là bất kỳ đối tượng giống như byte 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]])

Giống như

[1, 4, 9, 16, 25]
0328 nhưng tăng lên
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 khi không tìm thấy chuỗi phụ

Dãy con cần tìm có thể là bất kỳ đối tượng giống như byte 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-bộ chứa phần trước dấu tách, bản thân 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ỳ đối tượng giống như byte .

byte. startswith(tiền tố[ , . start[, end]])bytearray.startswith(tiền tố[ , start[, end]])

Trả về

[1, 4, 9, 16, 25]
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ề
[1, 4, 9, 16, 25]
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ỳ đối tượng giống như byte .

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 đối số tùy chọn xóa đề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

[1, 4, 9, 16, 25]
1606 để tạo bảng dịch

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

[1, 4, 9, 16, 25]
631 cho các bản dịch chỉ xóa các ký tự

[1, 4, 9, 16, 25]
994

Đã 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

[1, 4, 9, 16, 25]
9023, chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
[1, 4, 9, 16, 25]
9013

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

[1, 4, 9, 16, 25]
9023, chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
[1, 4, 9, 16, 25]
9013

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ị bỏ qua hoặc

[1, 4, 9, 16, 25]
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ố;

[1, 4, 9, 16, 25]
995

Chuỗi nhị phân của các giá trị byte cần xóa có thể là bất kỳ đối tượng giống byte . Xem

[1, 4, 9, 16, 25]
1613 để biết 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ụ.

[1, 4, 9, 16, 25]
996

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

[1, 4, 9, 16, 25]
9023, chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
[1, 4, 9, 16, 25]
9013

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

[1, 4, 9, 16, 25]
631, bất kỳ dãy con nào chỉ bao gồm khoảng trắng ASCII đều là dấu phân cách. Ngoại trừ tách từ bên phải,
[1, 4, 9, 16, 25]
0332 hoạt động giống như
[1, 4, 9, 16, 25]
0333 được mô tả chi tiết bên dưới

byte. 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ị bỏ qua hoặc

[1, 4, 9, 16, 25]
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ố;

[1, 4, 9, 16, 25]
997

Chuỗi nhị phân của các giá trị byte cần xóa có thể là bất kỳ đối tượng giống byte . Xem

[1, 4, 9, 16, 25]
1620 để biết phương pháp sẽ xóa một chuỗi hậu tố thay vì tất cả một bộ ký tự. Ví dụ.

[1, 4, 9, 16, 25]
998

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

[1, 4, 9, 16, 25]
0336 phần tử). Nếu maxsplit không được chỉ định hoặc là
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
541, 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 cung cấp, các dấu phân tách liên tiếp không được nhóm lại với nhau và được coi là phân tách các chuỗi con trống (ví dụ:

[1, 4, 9, 16, 25]
1623 trả về
[1, 4, 9, 16, 25]
1624). Đối số sep có thể bao gồm một chuỗi nhiều byte (ví dụ:
[1, 4, 9, 16, 25]
1625 trả về
[1, 4, 9, 16, 25]
1626). Tách một chuỗi trống với một dấu phân cách được chỉ định trả về
[1, 4, 9, 16, 25]
1627 hoặc
[1, 4, 9, 16, 25]
1628 tùy thuộc vào loại đối tượng được tách. Đối số sep có thể là bất kỳ đối tượng giống như byte .

Ví dụ

[1, 4, 9, 16, 25]
999

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

[1, 4, 9, 16, 25]
631, một thuật toán phân tách khác sẽ được áp dụng. các khoảng trắng ASCII liên tiếp được coi là một dấu phân cách duy nhất và kết quả sẽ không chứa chuỗi trống ở đầu hoặc cuối nếu chuỗi có khoảng trắng ở đầu hoặc cuối. Do đó, việc tách một chuỗi trống hoặc một chuỗi chỉ bao gồm khoảng trắng ASCII mà không có dấu tách được chỉ định sẽ trả về
[1, 4, 9, 16, 25]
649

Ví dụ

[1, 4, 9, 16, 25]
000

byte. 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ị bỏ qua hoặc

[1, 4, 9, 16, 25]
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ố;

[1, 4, 9, 16, 25]
001

Chuỗi nhị phân của các giá trị byte cần xóa có thể là bất kỳ đối tượng giống byte .

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()bytearray. 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à một ký tự tab ASCII (______21632), 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 (

[1, 4, 9, 16, 25]
1633) hoặc ký tự xuống dòng (
[1, 4, 9, 16, 25]
1634), 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

[1, 4, 9, 16, 25]
002

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ề

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
638. Các ký tự ASCII theo bảng chữ cái là các giá trị byte đó trong chuỗi
[1, 4, 9, 16, 25]
1637. Các chữ số thập phân ASCII là các giá trị byte đó trong chuỗi
[1, 4, 9, 16, 25]
1638

Ví dụ

[1, 4, 9, 16, 25]
003

byte. isalpha()bytearray. isalpha()

Trả về

[1, 4, 9, 16, 25]
656 nếu tất cả các byte trong chuỗi là ký tự ASCII theo bảng chữ cái và chuỗi không trống, ngược lại là
[1, 4, 9, 16, 25]
638. Các ký tự ASCII theo bảng chữ cái là các giá trị byte đó trong chuỗi
[1, 4, 9, 16, 25]
1637

Ví dụ

[1, 4, 9, 16, 25]
004

byte. isascii()bytearray. isascii()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
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ề

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
638. Các chữ số thập phân ASCII là các giá trị byte đó trong chuỗi
[1, 4, 9, 16, 25]
1638

Ví dụ

[1, 4, 9, 16, 25]
005

byte. islower()bytearray. giảm tốc()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
638

Ví dụ

[1, 4, 9, 16, 25]
006

Các ký tự ASCII chữ thường là các giá trị byte đó trong chuỗi

[1, 4, 9, 16, 25]
1649. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗi
[1, 4, 9, 16, 25]
1650

byte. không gian()bytearray. không gian()

Trả về

[1, 4, 9, 16, 25]
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à
[1, 4, 9, 16, 25]
638. Các ký tự khoảng trắng ASCII là các giá trị byte đó trong chuỗi
[1, 4, 9, 16, 25]
1653 (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ề

[1, 4, 9, 16, 25]
656 nếu chuỗi là chữ cái tiêu đề ASCII và chuỗi không trống, ngược lại là
[1, 4, 9, 16, 25]
638. Xem
[1, 4, 9, 16, 25]
1656 để biết thêm chi tiết về định nghĩa của “titlecase”

Ví dụ

[1, 4, 9, 16, 25]
007

byte. issupper()bytearray. ăn tối()

Trả về

[1, 4, 9, 16, 25]
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, nếu không thì là
[1, 4, 9, 16, 25]
638

Ví dụ

[1, 4, 9, 16, 25]
008

Các ký tự ASCII chữ thường là các giá trị byte đó trong chuỗi

[1, 4, 9, 16, 25]
1649. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗi
[1, 4, 9, 16, 25]
1650

byte. hạ()bytearray. thấp hơn()

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

Ví dụ

[1, 4, 9, 16, 25]
009

Các ký tự ASCII chữ thường là các giá trị byte đó trong chuỗi

[1, 4, 9, 16, 25]
1649. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗi
[1, 4, 9, 16, 25]
1650

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 dòng mới chung để 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ụ

[1, 4, 9, 16, 25]
030

Không giống như

[1, 4, 9, 16, 25]
0333 khi một chuỗi phân cách sep được cung cấp, 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 ở đầu cuối không dẫn đến một dòng thừa

[1, 4, 9, 16, 25]
031

byte. swapcase()bytearray. hoán đổi()

Trả về một bản sao của chuỗi với tất cả các ký tự ASCII chữ thường được chuyển đổi thành chữ hoa tương ứng của chúng và ngược lại

Ví dụ

[1, 4, 9, 16, 25]
032

Các ký tự ASCII chữ thường là các giá trị byte đó trong chuỗi

[1, 4, 9, 16, 25]
1649. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗi
[1, 4, 9, 16, 25]
1650

Không giống như

[1, 4, 9, 16, 25]
1666, luôn luôn xảy ra trường hợp
[1, 4, 9, 16, 25]
1667 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ụ

[1, 4, 9, 16, 25]
033

Các ký tự ASCII chữ thường là các giá trị byte đó trong chuỗi

[1, 4, 9, 16, 25]
1649. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗi
[1, 4, 9, 16, 25]
1650. 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

[1, 4, 9, 16, 25]
034

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

[1, 4, 9, 16, 25]
035

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. phía 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ụ

[1, 4, 9, 16, 25]
036

Các ký tự ASCII chữ thường là các giá trị byte đó trong chuỗi

[1, 4, 9, 16, 25]
1649. Các ký tự ASCII chữ hoa là các giá trị byte trong chuỗi
[1, 4, 9, 16, 25]
1650

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

[1, 4, 9, 16, 25]
1672 để tạo một chuỗi có chiều dài chiều rộng. Tiền tố dấu hiệu ở đầu (
[1, 4, 9, 16, 25]
1673/
[1, 4, 9, 16, 25]
1674) đượ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
[1, 4, 9, 16, 25]
9023, chuỗi ban đầu được trả về nếu chiều rộng nhỏ hơn hoặc bằng
[1, 4, 9, 16, 25]
1676

Ví dụ

[1, 4, 9, 16, 25]
037

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 [1, 4, 9, 16, 25]0026¶

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 (

[1, 4, 9, 16, 25]
9023/
[1, 4, 9, 16, 25]
9024) có một thao tác tích hợp duy nhất. toán tử
[1, 4, 9, 16, 25]
0382 (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
[1, 4, 9, 16, 25]
0383 (trong đó định dạng là đối tượng byte), thông số kỹ thuật chuyển đổi của
[1, 4, 9, 16, 25]
0382 ở định dạng được thay thế bằng 0 hoặc nhiều thành phần giá trị. Hiệu quả tương tự như sử dụng
[1, 4, 9, 16, 25]
0385 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. 5 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

  1. Ký tự

    [1, 4, 9, 16, 25]
    0386, đánh dấu sự bắt đầu của trình xác định

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

    [1, 4, 9, 16, 25]
    0387)

  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. Độ rộng trường tối thiểu (tùy chọn). Nếu được chỉ định là

    [1, 4, 9, 16, 25]
    0388 (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

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

    [1, 4, 9, 16, 25]
    0389 (dấu chấm) theo sau là độ chính xác. Nếu được chỉ định là
    [1, 4, 9, 16, 25]
    0388 (dấu hoa thị), thì độ chính xác thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu theo giá trị và giá trị cần chuyển đổi xuất hiện sau độ chính xác

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

  7. 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 đố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ự

[1, 4, 9, 16, 25]
0386. Phím ánh xạ chọn giá trị được định dạng từ ánh xạ. Ví dụ

[1, 4, 9, 16, 25]
038

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

[1, 4, 9, 16, 25]
9000 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

[1, 4, 9, 16, 25]
0393

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)

[1, 4, 9, 16, 25]
0376

Chuyển đổi sẽ được đệm bằng 0 cho các giá trị số

[1, 4, 9, 16, 25]
0378

Giá trị chuyển đổi được điều chỉnh trái (ghi đè chuyển đổi

[1, 4, 9, 16, 25]
0376 nếu cả hai được cung cấp)

[1, 4, 9, 16, 25]
0397

(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ý

[1, 4, 9, 16, 25]
0377

Một ký tự dấu (

[1, 4, 9, 16, 25]
0377 hoặc
[1, 4, 9, 16, 25]
0378) sẽ đứng trước chuyển đổi (ghi đè cờ “dấu cách”)

Có thể có công cụ sửa đổi độ dài (

[1, 4, 9, 16, 25]
0801,
[1, 4, 9, 16, 25]
0802 hoặc
[1, 4, 9, 16, 25]
0803), nhưng bị bỏ qua vì nó không cần thiết đối với Python – vì vậy e. g.
[1, 4, 9, 16, 25]
0804 giống hệt với
[1, 4, 9, 16, 25]
0805

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

chuyển đổi

Nghĩa

ghi chú

[1, 4, 9, 16, 25]
0806

Số thập phân có dấu

[1, 4, 9, 16, 25]
0807

Số thập phân có dấu

[1, 4, 9, 16, 25]
0808

Giá trị bát phân đã ký

(1)

[1, 4, 9, 16, 25]
0809

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

[1, 4, 9, 16, 25]
0806

(số 8)

[1, 4, 9, 16, 25]
0811

Đã ký thập lục phân (chữ thường)

(2)

[1, 4, 9, 16, 25]
0812

Đã ký thập lục phân (chữ hoa)

(2)

[1, 4, 9, 16, 25]
0813

Định dạng số mũ dấu phẩy động (chữ thường)

(3)

[1, 4, 9, 16, 25]
0814

Định dạng số mũ dấu phẩy động (chữ hoa)

(3)

[1, 4, 9, 16, 25]
0815

Định dạng thập phân dấu phẩy động

(3)

[1, 4, 9, 16, 25]
0816

Định dạng thập phân dấu phẩy động

(3)

[1, 4, 9, 16, 25]
0817

Đị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)

[1, 4, 9, 16, 25]
0818

Đị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)

[1, 4, 9, 16, 25]
0819

Byte đơn (chấp nhận đối tượng số nguyên hoặc byte đơn)

[1, 4, 9, 16, 25]
6018

Byte (bất kỳ đối tượng nào tuân theo giao thức bộ đệm hoặc có

[1, 4, 9, 16, 25]
6019).

(5)

[1, 4, 9, 16, 25]
0822

[1, 4, 9, 16, 25]
0822 là bí danh của
[1, 4, 9, 16, 25]
6018 và chỉ nên được sử dụng cho cơ sở mã Python2/3

(6)

[1, 4, 9, 16, 25]
0824

Byte (chuyển đổi bất kỳ đối tượng Python nào bằng cách sử dụng

[1, 4, 9, 16, 25]
6024)

(5)

[1, 4, 9, 16, 25]
0820

[1, 4, 9, 16, 25]
0820 là bí danh của
[1, 4, 9, 16, 25]
0824 và chỉ nên được sử dụng cho cơ sở mã Python2/3

(7)

[1, 4, 9, 16, 25]
0386

Không có đối số nào được chuyển đổi, dẫn đến ký tự

[1, 4, 9, 16, 25]
0386 trong kết quả

ghi chú

  1. Dạng thay thế làm cho một bộ xác định bát phân hàng đầu (

    [1, 4, 9, 16, 25]
    0828) được chèn vào trước chữ số đầu tiên

  2. Biểu mẫu thay thế làm cho một

    [1, 4, 9, 16, 25]
    0829 hoặc
    [1, 4, 9, 16, 25]
    0830 ở đầu (tùy thuộc vào việc định dạng
    [1, 4, 9, 16, 25]
    0811 hoặc
    [1, 4, 9, 16, 25]
    0812 được sử dụng) được chèn vào trước chữ số đầu tiên

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

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

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

    [1, 4, 9, 16, 25]
    0833, đầu ra bị cắt bớt thành
    [1, 4, 9, 16, 25]
    0833 ký tự

  6. [1, 4, 9, 16, 25]
    6037 không được dùng nữa, nhưng sẽ không bị xóa trong 3. sê-ri x

  7. [1, 4, 9, 16, 25]
    6038 không được dùng nữa, nhưng sẽ không bị xóa trong 3. sê-ri x

  8. Xem 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ớ¶

[1, 4, 9, 16, 25]
0841 cho phép mã Python truy cập dữ liệu bên trong của một đối tượng hỗ trợ giao thức bộ đệm mà không cần sao chép.

lớp chế độ xem bộ nhớ(đối tượng)

Tạo một

[1, 4, 9, 16, 25]
0841 tham chiếu đối tượng. đối tượng phải hỗ trợ giao thức đệm. Các đối tượng tích hợp hỗ trợ giao thức bộ đệm bao gồm
[1, 4, 9, 16, 25]
9023 và
[1, 4, 9, 16, 25]
9024

Một

[1, 4, 9, 16, 25]
0841 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 ban đầu. Đối với nhiều loại đơn giản như
[1, 4, 9, 16, 25]
9023 và
[1, 4, 9, 16, 25]
9024, một phần tử là một byte đơn, nhưng các loại khác như
[1, 4, 9, 16, 25]
6046 có thể có các phần tử lớn hơn

[1, 4, 9, 16, 25]
6047 bằng chiều dài của
[1, 4, 9, 16, 25]
6048. Nếu
[1, 4, 9, 16, 25]
6049, độ dài là 1. Nếu
[1, 4, 9, 16, 25]
6050, độ dài bằng số phần tử trong dạng xem. Đố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
[1, 4, 9, 16, 25]
6051 sẽ cung cấp cho bạn số byte trong một phần tử

Một

[1, 4, 9, 16, 25]
0841 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ụ

[1, 4, 9, 16, 25]
039

Nếu

[1, 4, 9, 16, 25]
6053 là một trong những công cụ xác định định dạng gốc từ mô-đun
[1, 4, 9, 16, 25]
6054, 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 đúng loại. 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

[1, 4, 9, 16, 25]
080

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

[1, 4, 9, 16, 25]
081

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à

[1, 4, 9, 16, 25]
6055

[1, 4, 9, 16, 25]
082

Đã 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

[1, 4, 9, 16, 25]
8996

Đã 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.

[1, 4, 9, 16, 25]
0841 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

[1, 4, 9, 16, 25]
6054

Đối với tập hợp con của các chuỗi định dạng

[1, 4, 9, 16, 25]
6054 hiện được hỗ trợ bởi
[1, 4, 9, 16, 25]
6060,
[1, 4, 9, 16, 25]
6061 và
[1, 4, 9, 16, 25]
6062 bằng nhau nếu
[1, 4, 9, 16, 25]
6063

[1, 4, 9, 16, 25]
083

Nếu một trong hai chuỗi định dạng không được mô-đun

[1, 4, 9, 16, 25]
6054 hỗ trợ, thì các đối tượng sẽ luôn được 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)

[1, 4, 9, 16, 25]
084

Lưu ý rằng, như với các số dấu phẩy động,

[1, 4, 9, 16, 25]
6065 không ngụ ý
[1, 4, 9, 16, 25]
6066 đố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')

Trả lại dữ liệu trong bộ đệm dưới dạng chuỗi ký tự. Điều này tương đương với việc gọi hàm tạo

[1, 4, 9, 16, 25]
9023 trên memoryview

[1, 4, 9, 16, 25]
085

Đố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.

[1, 4, 9, 16, 25]
6068 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
[1, 4, 9, 16, 25]
6054

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

[1, 4, 9, 16, 25]
086

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

Đã thay đổi trong phiên bản 3. 8. Tương tự như

[1, 4, 9, 16, 25]
0859,
[1, 4, 9, 16, 25]
6071 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.

tolist()

Trả về dữ liệu trong bộ đệm dưới dạng danh sách các phần tử

[1, 4, 9, 16, 25]
087

Đã thay đổi trong phiên bản 3. 3. ______26060 hiện hỗ trợ tất cả các định dạng gốc ký tự đơn trong cú pháp mô-đun

[1, 4, 9, 16, 25]
6054 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

[1, 4, 9, 16, 25]
088

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

bản 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ụ:

[1, 4, 9, 16, 25]
9024 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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 (ngoại trừ bản thân
[1, 4, 9, 16, 25]
6076 có thể được gọi nhiều lần)

[1, 4, 9, 16, 25]
089

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

[1, 4, 9, 16, 25]
6077

[1, 4, 9, 16, 25]
160

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

truyền(định dạng[ , shape])

Truyền dạng xem bộ nhớ sang định dạng hoặc hình dạng mới. hình dạng mặc định là

[1, 4, 9, 16, 25]
6078, 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- tiếp giáp 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

[1, 4, 9, 16, 25]
6054. 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

[1, 4, 9, 16, 25]
161

Truyền 1D/byte không dấu thành 1D/char

[1, 4, 9, 16, 25]
162

Truyền 1D/byte thành 3D/int thành 1D/char đã ký

[1, 4, 9, 16, 25]
163

Truyền 1D/dài không dấu thành 2D/dài không dấu

[1, 4, 9, 16, 25]
164

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

obj

Đối tượng cơ bản của memoryview

[1, 4, 9, 16, 25]
165

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

nbyte

[1, 4, 9, 16, 25]
6080. Đâ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
[1, 4, 9, 16, 25]
6081

[1, 4, 9, 16, 25]
166

mảng nhiều chiều

[1, 4, 9, 16, 25]
167

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

chỉ đọc

Một bool cho biết bộ nhớ có ở chế độ chỉ đọc hay không

định dạng

Một chuỗi chứa định dạng (theo kiểu mô-đun

[1, 4, 9, 16, 25]
6054) 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.
[1, 4, 9, 16, 25]
6060) bị giới hạn ở các định dạng phần tử đơn gốc

Đã thay đổi trong phiên bản 3. 3. định dạng

[1, 4, 9, 16, 25]
6084 hiện được xử lý theo cú pháp mô-đun cấu trúc. Điều này có nghĩa là
[1, 4, 9, 16, 25]
6085.

kích thước mặt hàng

Kích thước tính bằng byte của từng phần tử của memoryview

[1, 4, 9, 16, 25]
168

ndim

Một số nguyên cho biết có bao nhiêu chiều của một mảng nhiều chiều mà bộ nhớ đại diện

hình dạng

Một bộ số nguyên có độ dài bằng

[1, 4, 9, 16, 25]
6086 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ì

[1, 4, 9, 16, 25]
631 khi ndim = 0.

sải chân

Một bộ số nguyên có độ dài

[1, 4, 9, 16, 25]
6086 cung cấp kích thước tính bằng 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ì

[1, 4, 9, 16, 25]
631 khi ndim = 0.

độ lệch con

Được sử dụng nội bộ cho mảng kiểu PIL. Giá trị chỉ là thông tin

c_contiguous

Một bool cho biết liệu bộ nhớ có phải là C- tiếp giáp .

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

f_contiguous

Một bool cho biết bộ nhớ có phải là Fortran hay không tiếp giáp .

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

tiếp giáp

Một bool cho biết liệu bộ nhớ có liền kề .

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

Các loại tập hợp — [1, 4, 9, 16, 25]9069, [1, 4, 9, 16, 25]9070¶

Đối tượng tập hợp là một tập hợp không theo thứ tự các đối tượng có thể băm riêng biệt. Các ứng dụng phổ biến bao gồm kiểm tra tư cách thành viên, loại bỏ các bản trùng lặp khỏi chuỗi và tính toán các phép toán như giao, hợp, hiệu và hiệu đối xứng. (Đối với các vùng chứa khác, hãy xem các lớp

[1, 4, 9, 16, 25]
9068,
[1, 4, 9, 16, 25]
8993 và
[1, 4, 9, 16, 25]
8994 tích hợp sẵn và mô-đun
[1, 4, 9, 16, 25]
6095. )

Giống như các bộ sưu tập khác, bộ hỗ trợ

[1, 4, 9, 16, 25]
6096,
[1, 4, 9, 16, 25]
6097 và
[1, 4, 9, 16, 25]
6098. 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 bộ tích hợp sẵn,

[1, 4, 9, 16, 25]
9069 và
[1, 4, 9, 16, 25]
9070. Loại
[1, 4, 9, 16, 25]
9069 có thể thay đổi — có thể thay đổi nội dung bằng các phương pháp như
[1, 4, 9, 16, 25]
6102 và
[1, 4, 9, 16, 25]
9901. 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
[1, 4, 9, 16, 25]
9070 là bất biến và có thể băm — không thể thay đổi nội dung của nó sau khi đượ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.

[1, 4, 9, 16, 25]
6105, ngoài hàm tạo
[1, 4, 9, 16, 25]
9069

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 tập hợp phải có thể băm được . Để đại diện cho các tập hợp, các tập hợp bên trong phải là đối tượng

[1, 4, 9, 16, 25]
9070. 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.

    [1, 4, 9, 16, 25]
    6105

  • Sử dụng một bộ hiểu.

    [1, 4, 9, 16, 25]
    6109

  • Sử dụng hàm tạo kiểu.

    [1, 4, 9, 16, 25]
    651,
    [1, 4, 9, 16, 25]
    6111,
    [1, 4, 9, 16, 25]
    6112

Các trường hợp của

[1, 4, 9, 16, 25]
9069 và
[1, 4, 9, 16, 25]
9070 cung cấp các thao tác sau

(các) ống kính

Trả về số phần tử trong tập hợp s (số lượng của s)

x in s

Kiểm tra x cho tư cách thành viên trong s

x không vào s

Kiểm tra x cho người không phải là thành viên trong s

isdisjoint(other)

Trả về

[1, 4, 9, 16, 25]
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ỗng

tập hợp con(khác)set <= other

Kiểm tra xem mọi phần tử trong tập hợp có thuộc tập hợp khác không

đặt < khác

Kiểm tra xem tập hợp này có phải là tập hợp con thích hợp của tập hợp khác hay không, nghĩa là,

[1, 4, 9, 16, 25]
6116

issuperset(other)set >= other

Kiểm tra xem mọi phần tử trong tập hợp khác có nằm trong tập hợp không

đặt > khác

Kiểm tra xem tập hợp này có phải là tập hợp lớn nhất của tập hợp khác hay không, nghĩa là,

[1, 4, 9, 16, 25]
6117

công đoàn(*những người khác)set | khác . .

Trả về một tập hợp mới với các phần tử từ tập hợp và tất cả các phần tử khác

giao lộ(*các ngã tư khác)set & other & ...

Trả về một tập hợp mới với các phần tử chung cho tập hợp và tất cả các phần tử khác

sự khác biệt(*khác)set - other - ...

Trả về một tập hợp mới với các phần tử trong tập hợp không có trong các phần tử khác

symmetric_difference(khác)set ^ other

Trả về một tập hợp mới có các phần tử trong tập hợp này hoặc tập hợp khác nhưng không phải cả hai

bản sao()

Trả lại một bản sao nông của tập hợp

Lưu ý, các phiên bản không phải toán tử của các phương thức

[1, 4, 9, 16, 25]
6118,
[1, 4, 9, 16, 25]
6119,
[1, 4, 9, 16, 25]
6120,
[1, 4, 9, 16, 25]
6121,
[1, 4, 9, 16, 25]
6122 và
[1, 4, 9, 16, 25]
6123 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ư
[1, 4, 9, 16, 25]
6124 để có thể đọc dễ dàng hơn
[1, 4, 9, 16, 25]
6125

Cả hai thiết lập hỗ trợ

[1, 4, 9, 16, 25]
9069 và
[1, 4, 9, 16, 25]
9070 để thiết lập 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 phiên bản của

[1, 4, 9, 16, 25]
9069 được so sánh với các phiên bản của
[1, 4, 9, 16, 25]
9070 dựa trên các thành viên của chúng. Ví dụ:
[1, 4, 9, 16, 25]
6130 trả về
[1, 4, 9, 16, 25]
656 và
[1, 4, 9, 16, 25]
6132 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 hợp con của nhau, vì vậy tất cả các giá trị sau trả về

[1, 4, 9, 16, 25]
638.
[1, 4, 9, 16, 25]
6134,
[1, 4, 9, 16, 25]
6135 hoặc
[1, 4, 9, 16, 25]
6136

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

[1, 4, 9, 16, 25]
6137 không được xác định cho danh sách các tập hợp

Các thành phần của tập hợp, như khóa từ điển, phải có thể băm .

Các hoạt động nhị phân kết hợp các phiên bản

[1, 4, 9, 16, 25]
9069 với
[1, 4, 9, 16, 25]
9070 trả về loại toán hạng đầu tiên. Ví dụ.
[1, 4, 9, 16, 25]
6140 trả về một thể hiện của
[1, 4, 9, 16, 25]
9070

Bảng sau đây liệt kê các hoạt động có sẵn cho

[1, 4, 9, 16, 25]
9069 không áp dụng cho các trường hợp bất biến của
[1, 4, 9, 16, 25]
9070

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)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 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

[1, 4, 9, 16, 25]
6144 nếu elem không có trong tập hợp

loại bỏ(elem)

Xóa phần tử elem khỏi tập hợp nếu có

pop()

Xóa và trả về một phần tử tùy ý khỏi tập hợp. Tăng

[1, 4, 9, 16, 25]
6144 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

[1, 4, 9, 16, 25]
6146,
[1, 4, 9, 16, 25]
6147,
[1, 4, 9, 16, 25]
6148 và
[1, 4, 9, 16, 25]
6149 sẽ chấp nhận bất kỳ lần lặp nào làm đối số

Lưu ý, đối số elem cho các phương thức

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
500,
[1, 4, 9, 16, 25]
9901 và
[1, 4, 9, 16, 25]
6152 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ạ — [1, 4, 9, 16, 25]9068¶

A ánh xạ đối tượng ánh xạ các giá trị có thể băm thành 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

[1, 4, 9, 16, 25]
8993,
[1, 4, 9, 16, 25]
9069 và
[1, 4, 9, 16, 25]
8994 tích hợp sẵn và mô-đun
[1, 4, 9, 16, 25]
6095. )

Khóa của từ điển gần như là giá trị tùy ý. Các giá trị không có thể băm , 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ác giá trị so sánh bằng nhau (chẳng hạn như

[1, 4, 9, 16, 25]
655,
[1, 4, 9, 16, 25]
6159 và
[1, 4, 9, 16, 25]
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ển.

class dict(**kwargs)class dict(mapping, **kwargs)class dict(iterable, **kwargs)

Trả về một từ điển mới được khởi tạo từ một đối số vị trí tùy chọn và một bộ đối số từ khóa có thể trống

Từ điển có thể được tạo ra bằng nhiều cách

  • Sử dụng danh sách các cặp

    [1, 4, 9, 16, 25]
    6161 được phân tách bằng dấu phẩy trong dấu ngoặc nhọn.
    [1, 4, 9, 16, 25]
    6162 hoặc
    [1, 4, 9, 16, 25]
    6163

  • Sử dụng hiểu chính tả.

    [1, 4, 9, 16, 25]
    650,
    [1, 4, 9, 16, 25]
    6165

  • Sử dụng hàm tạo kiểu.

    [1, 4, 9, 16, 25]
    6166,
    [1, 4, 9, 16, 25]
    6167,
    [1, 4, 9, 16, 25]
    6168

Nếu không có đối số vị trí nào được cung cấp, 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 có thể lặp lại . 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

[1, 4, 9, 16, 25]
6169

[1, 4, 9, 16, 25]
169

Việc cung cấp các đối số từ khóa như trong ví dụ đầu tiên chỉ hoạt động đối với các khóa là mã định danh Python hợp lệ. Mặt khác, bất kỳ khóa hợp lệ nào cũng có thể được sử dụng

Đây là các hoạt động mà từ điển hỗ trợ (và do đó, các loại ánh xạ tùy chỉnh cũng sẽ hỗ trợ)

danh sách(d)

Trả về danh sách tất cả các khóa được sử dụng trong từ điển d

cho vay)

Trả về số mục trong từ điển d

đ[phím]

Trả lại mục của d bằng phím key. Tăng

[1, 4, 9, 16, 25]
6144 nếu khóa 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

[1, 4, 9, 16, 25]
6171 và không có khóa, thì hoạt động
[1, 4, 9, 16, 25]
6172 sẽ gọi phương thức đó với đối số là key key. Hoạt động
[1, 4, 9, 16, 25]
6172 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
[1, 4, 9, 16, 25]
6174. Không có hoạt động hoặc phương thức nào khác gọi
[1, 4, 9, 16, 25]
6171. Nếu
[1, 4, 9, 16, 25]
6171 không được xác định, thì
[1, 4, 9, 16, 25]
6144 được nâng lên.
[1, 4, 9, 16, 25]
6171 phải là một phương thức;

[1, 4, 9, 16, 25]
600

Ví dụ trên cho thấy một phần của việc triển khai

[1, 4, 9, 16, 25]
6179. Một phương thức khác của
[1, 4, 9, 16, 25]
6180 được sử dụng bởi
[1, 4, 9, 16, 25]
6181

d[key] = giá trị

Đặt

[1, 4, 9, 16, 25]
6172 thành giá trị

del d[key]

Xóa

[1, 4, 9, 16, 25]
6172 khỏi d. Tăng
[1, 4, 9, 16, 25]
6144 nếu khóa không có trong bản đồ

phím vào d

Trả lại

[1, 4, 9, 16, 25]
656 nếu d có khóa chính, ngược lại
[1, 4, 9, 16, 25]
638

phím không vào d

Tương đương với

[1, 4, 9, 16, 25]
6187

lặ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

[1, 4, 9, 16, 25]
6188

xóa()

Xóa tất cả các mục khỏi từ điển

bản sao()

Trả lại một bản sao nông của từ điển

phương thức lớp từ khóa(có thể lặp lại[, value])

Tạo một từ điển mới với các khóa từ iterable và các giá trị được đặt thành giá trị

[1, 4, 9, 16, 25]
6189 là một phương thức lớp trả về một từ điển mới. giá trị mặc định là
[1, 4, 9, 16, 25]
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 hiểu chính tả 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à

[1, 4, 9, 16, 25]
631, do đó phương pháp này không bao giờ tăng giá trị
[1, 4, 9, 16, 25]
6144

items()

Trả về chế độ xem mới cho các mục của từ điển (

[1, 4, 9, 16, 25]
6193 cặp). Xem tài liệu về đối tượng xem .

phím()

Trả lại chế độ xem mới cho các khóa của từ điển. Xem tài liệu về đối tượng 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, thì một số

[1, 4, 9, 16, 25]
6144 sẽ xuất hiện

popitem()

Xóa và trả về cặp

[1, 4, 9, 16, 25]
6193 từ từ điển. Các cặp được trả lại theo thứ tự LIFO

[1, 4, 9, 16, 25]
6196 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, gọi
[1, 4, 9, 16, 25]
6196 sẽ tăng
[1, 4, 9, 16, 25]
6144

Đã 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,

[1, 4, 9, 16, 25]
6196 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

[1, 4, 9, 16, 25]
6200

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à

[1, 4, 9, 16, 25]
631

cập nhật([khác])

Cập nhật từ điển với các cặp khóa/giá trị từ khác, ghi đè lên các khóa hiện có. Trả lại

[1, 4, 9, 16, 25]
631

[1, 4, 9, 16, 25]
6146 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ị đó.
[1, 4, 9, 16, 25]
6204

giá trị()

Trả về chế độ xem mới cho các giá trị của từ điển. Xem tài liệu về đối tượng xem .

So sánh bình đẳng giữa một chế độ xem

[1, 4, 9, 16, 25]
6205 và chế độ xem khác sẽ luôn trả về
[1, 4, 9, 16, 25]
638. Điều này cũng áp dụng khi so sánh
[1, 4, 9, 16, 25]
6205 với chính nó

[1, 4, 9, 16, 25]
601

d . khác

Tạo một từ điển mới với các khóa và giá trị được hợp nhất của d và khác, cả hai phải là từ điển. Các giá trị của other được ưu tiên khi d và các khóa chia sẻ khác

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

d . = khác

Cập nhật từ điển d với các khóa và giá trị từ từ điển khác, có thể là ánh xạ hoặc iterable of key/value pairs. The values of other take priority when d and other share keys.

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

Dictionaries compare equal if and only if they have the same

[1, 4, 9, 16, 25]
6193 pairs (regardless of ordering). Order comparisons (‘<’, ‘<=’, ‘>=’, ‘>’) raise
[1, 4, 9, 16, 25]
688.

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

[1, 4, 9, 16, 25]
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

[1, 4, 9, 16, 25]
603

Đã thay đổi trong phiên bản 3. 8. Từ điển hiện có thể đảo ngược.

Xem thêm

[1, 4, 9, 16, 25]
6210 có thể được sử dụng để tạo chế độ xem chỉ đọc của
[1, 4, 9, 16, 25]
9068

Đối tượng xem từ điển¶

Các đối tượng được trả về bởi

[1, 4, 9, 16, 25]
6212,
[1, 4, 9, 16, 25]
6205 và
[1, 4, 9, 16, 25]
6214 là các đối tượng dạ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

[1, 4, 9, 16, 25]
6193) 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

[1, 4, 9, 16, 25]
6216 bằng cách sử dụng
[1, 4, 9, 16, 25]
6217.
[1, 4, 9, 16, 25]
6218. Một cách khác để tạo danh sách tương tự là
[1, 4, 9, 16, 25]
6219

Việc lặp lại các chế độ xem trong khi thêm hoặc xóa các mục nhập trong từ điển có thể làm tăng

[1, 4, 9, 16, 25]
6220 hoặc không thể lặp lại tất cả các mục nhập

Đã 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 dictview

Trả về

[1, 4, 9, 16, 25]
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
[1, 4, 9, 16, 25]
6193)

đả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 một

[1, 4, 9, 16, 25]
6210 bao bọc từ điển gốc mà chế độ xem đề cập đến

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

Các 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 được. Nếu tất cả các giá trị đều có thể băm, để các cặp

[1, 4, 9, 16, 25]
6193 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
[1, 4, 9, 16, 25]
6225 đều khả dụng (ví dụ:
[1, 4, 9, 16, 25]
678,
[1, 4, 9, 16, 25]
674 hoặc
[1, 4, 9, 16, 25]
6228)

Một ví dụ về việc sử dụng chế độ xem từ điển

[1, 4, 9, 16, 25]
604

Các loại trình quản lý ngữ cảnh¶

Câu lệnh

[1, 4, 9, 16, 25]
6077 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 đề

[1, 4, 9, 16, 25]
6230 của câu lệnh
[1, 4, 9, 16, 25]
6077 bằng trình quản lý bối cảnh này

Ví dụ về trình quản lý bối cảnh tự trả về là một đối tượng tệp . Các đối tượng tệp tự trả về từ __enter__() để cho phép sử dụng

[1, 4, 9, 16, 25]
6232 làm biểu thức ngữ cảnh trong câu lệnh
[1, 4, 9, 16, 25]
6077.

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

[1, 4, 9, 16, 25]
6234. 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 nội dung của câu lệnh
[1, 4, 9, 16, 25]
6077 mà không ảnh hưởng đến mã bên ngoài câu lệnh
[1, 4, 9, 16, 25]
6077

trình quản lý ngữ cảnh. __exit__(exc_type , exc_val, exc_tb)

Thoát khỏi bối cảnh thời gian chạy và trả về một cờ Boolean cho biết liệu có nên loại bỏ bất kỳ ngoại lệ nào xảy ra hay không. Nếu một ngoại lệ xảy ra trong khi thực thi phần nội dung của câu lệnh

[1, 4, 9, 16, 25]
6077, 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ố là
[1, 4, 9, 16, 25]
631

Việc trả về một giá trị thực từ phương thức này sẽ khiến câu lệnh

[1, 4, 9, 16, 25]
6077 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
[1, 4, 9, 16, 25]
6077. 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 hiện 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
[1, 4, 9, 16, 25]
6077

Ngoại lệ được truyền vào không bao giờ được gọi lại một cách rõ ràng - thay vào đó, phương thức này sẽ trả về một giá trị sai để cho biết rằng phương thức đã hoàn tất thành công và không muốn chặn ngoại lệ đã nêu. Điều này cho phép mã quản lý bối cảnh dễ dàng phát hiện xem phương thức

[1, 4, 9, 16, 25]
6242 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

[1, 4, 9, 16, 25]
6243 để biết một số ví dụ

Trình tạo của Python và trình trang trí

[1, 4, 9, 16, 25]
6244 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í
[1, 4, 9, 16, 25]
6244, thì nó sẽ trả về trình quản lý bối cảnh thực hiện các phương thức
[1, 4, 9, 16, 25]
6246 và
[1, 4, 9, 16, 25]
6242 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ể

Loại chú thích loại — Bí danh chung , Liên kết ¶

Các loại tích hợp cốt lõi cho chú thích loạiBí danh chung and Union.

Loại bí danh chung¶

____26248 thường được tạo bằng cách đăng ký một lớp. Chúng thường được sử dụng nhất với các lớp vùng chứa , chẳng hạn như

[1, 4, 9, 16, 25]
8993 hoặc
[1, 4, 9, 16, 25]
9068. Ví dụ:
[1, 4, 9, 16, 25]
6251 là một đối tượng
[1, 4, 9, 16, 25]
6248 được tạo bằng cách đăng ký lớp
[1, 4, 9, 16, 25]
8993 với đối số
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501. Các đối tượng
[1, 4, 9, 16, 25]
6248 được thiết kế chủ yếu để sử dụng với chú thích loại .

Ghi chú

Thông thường chỉ có thể đăng ký một lớp nếu lớp đó triển khai phương thức đặc biệt

[1, 4, 9, 16, 25]
6256

Đối tượng

[1, 4, 9, 16, 25]
6248 hoạt động như một proxy cho loại chung , triển khai các loại chung được tham số hóa.

Đối với lớp vùng chứa, (các) đối số được cung cấp cho đăng ký của lớp có thể cho biết (các) loại phần tử . Ví dụ,

[1, 4, 9, 16, 25]
6258 có thể được sử dụng trong các chú thích loại để biểu thị một
[1, 4, 9, 16, 25]
9069 trong đó tất cả các phần tử thuộc loại
[1, 4, 9, 16, 25]
9023.

Đối với một lớp định nghĩa

[1, 4, 9, 16, 25]
6256 nhưng không phải là một vùng chứa, (các) đối số được cung cấp cho đăng ký của lớp thường sẽ chỉ ra (các) kiểu trả về của một hoặc nhiều phương thức được xác định trên một đối tượng. Ví dụ:
[1, 4, 9, 16, 25]
6262 có thể được sử dụng trên cả loại dữ liệu
[1, 4, 9, 16, 25]
9022 và loại dữ liệu
[1, 4, 9, 16, 25]
9023

  • Nếu

    [1, 4, 9, 16, 25]
    6265, thì
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    582 sẽ là lại. Khớp đối tượng trong đó các giá trị trả về của
    [1, 4, 9, 16, 25]
    6267 và
    [1, 4, 9, 16, 25]
    6268 đều thuộc loại
    [1, 4, 9, 16, 25]
    9022. Chúng ta có thể biểu diễn loại đối tượng này trong các chú thích kiểu với
    [1, 4, 9, 16, 25]
    6248
    [1, 4, 9, 16, 25]
    6271.

  • Nếu

    [1, 4, 9, 16, 25]
    6272, (lưu ý
    [1, 4, 9, 16, 25]
    0846 cho
    [1, 4, 9, 16, 25]
    9023), thì
    [1, 4, 9, 16, 25]
    8931 cũng sẽ là một thể hiện của
    [1, 4, 9, 16, 25]
    6276, nhưng các giá trị trả về của
    [1, 4, 9, 16, 25]
    6277 và
    [1, 4, 9, 16, 25]
    6278 đều sẽ thuộc loại
    [1, 4, 9, 16, 25]
    9023. Trong các chú thích loại, chúng tôi sẽ trình bày nhiều loại re. Khớp đối tượng với
    [1, 4, 9, 16, 25]
    6280.

Các đối tượng

[1, 4, 9, 16, 25]
6248 là các thể hiện của lớp
[1, 4, 9, 16, 25]
6282, cũng có thể được sử dụng để tạo trực tiếp các đối tượng
[1, 4, 9, 16, 25]
6248

T[X, Y, . ]

Tạo một

[1, 4, 9, 16, 25]
6248 đại diện cho một loại
[1, 4, 9, 16, 25]
6285 được tham số hóa bởi các loại X, Y, v.v. tùy thuộc vào
[1, 4, 9, 16, 25]
6285 được sử dụng. Ví dụ: một hàm mong đợi một
[1, 4, 9, 16, 25]
8993 chứa các phần tử
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
502

[1, 4, 9, 16, 25]
605

Một ví dụ khác cho các đối tượng ánh xạ , sử dụng

[1, 4, 9, 16, 25]
9068, là loại chung cần có 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
[1, 4, 9, 16, 25]
9068 với các khóa thuộc loại
[1, 4, 9, 16, 25]
9022 và các giá trị thuộc loại
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501.

[1, 4, 9, 16, 25]
606

Các hàm dựng sẵn

[1, 4, 9, 16, 25]
6293 và
[1, 4, 9, 16, 25]
6294 không chấp nhận các loại
[1, 4, 9, 16, 25]
6248 cho đối số thứ hai của chúng

[1, 4, 9, 16, 25]
607

Thời gian chạy Python không thực thi chú thích loại . Đ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ừ

[1, 4, 9, 16, 25]
6248, 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.

[1, 4, 9, 16, 25]
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

[1, 4, 9, 16, 25]
609

Gọi

[1, 4, 9, 16, 25]
632 hoặc
[1, 4, 9, 16, 25]
633 trên chung hiển thị loại được tham số hóa

[1, 4, 9, 16, 25]
610

Phương pháp

[1, 4, 9, 16, 25]
0368 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ư
[1, 4, 9, 16, 25]
6300

[1, 4, 9, 16, 25]
611

Tuy nhiên, các biểu thức như vậy hợp lệ khi sử dụng biến loại . 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

[1, 4, 9, 16, 25]
6248 của đối tượng
[1, 4, 9, 16, 25]
6302.

[1, 4, 9, 16, 25]
612

Các lớp học 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 đủ

  • [1, 4, 9, 16, 25]
    8994

  • [1, 4, 9, 16, 25]
    8993

  • [1, 4, 9, 16, 25]
    9068

  • [1, 4, 9, 16, 25]
    9069

  • [1, 4, 9, 16, 25]
    9070

  • [1, 4, 9, 16, 25]
    6308

  • [1, 4, 9, 16, 25]
    6309

  • [1, 4, 9, 16, 25]
    6181

  • [1, 4, 9, 16, 25]
    6311

  • [1, 4, 9, 16, 25]
    6179

  • [1, 4, 9, 16, 25]
    6313

  • [1, 4, 9, 16, 25]
    6314

  • [1, 4, 9, 16, 25]
    6315

  • [1, 4, 9, 16, 25]
    6316

  • [1, 4, 9, 16, 25]
    6317

  • [1, 4, 9, 16, 25]
    6318

  • [1, 4, 9, 16, 25]
    6319

  • [1, 4, 9, 16, 25]
    6320

  • [1, 4, 9, 16, 25]
    6321

  • [1, 4, 9, 16, 25]
    6322

  • [1, 4, 9, 16, 25]
    6323

  • [1, 4, 9, 16, 25]
    6324

  • [1, 4, 9, 16, 25]
    6325

  • [1, 4, 9, 16, 25]
    6225

  • [1, 4, 9, 16, 25]
    6327

  • [1, 4, 9, 16, 25]
    6328

  • [1, 4, 9, 16, 25]
    6329

  • [1, 4, 9, 16, 25]
    8996

  • [1, 4, 9, 16, 25]
    9072

  • [1, 4, 9, 16, 25]
    6332

  • [1, 4, 9, 16, 25]
    6333

  • [1, 4, 9, 16, 25]
    6334

  • [1, 4, 9, 16, 25]
    6335

  • [1, 4, 9, 16, 25]
    6336

  • [1, 4, 9, 16, 25]
    6337

  • [1, 4, 9, 16, 25]
    6338

  • [1, 4, 9, 16, 25]
    6339

  • [1, 4, 9, 16, 25]
    6340

  • [1, 4, 9, 16, 25]
    6341

  • [1, 4, 9, 16, 25]
    6342

  • [1, 4, 9, 16, 25]
    6343

  • [1, 4, 9, 16, 25]
    6344

  • [1, 4, 9, 16, 25]
    6345

  • [1, 4, 9, 16, 25]
    6346

  • lại. Họa tiết

  • lại. Cuộc thi đấu

  • [1, 4, 9, 16, 25]
    6347

  • [1, 4, 9, 16, 25]
    6348

  • [1, 4, 9, 16, 25]
    6349

  • [1, 4, 9, 16, 25]
    6210

  • [1, 4, 9, 16, 25]
    6351

  • [1, 4, 9, 16, 25]
    6352

  • [1, 4, 9, 16, 25]
    6353

  • [1, 4, 9, 16, 25]
    6354

Thuộc tính đặc biệt của đối tượng
[1, 4, 9, 16, 25]
6248¶

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

[1, 4, 9, 16, 25]
613

tên chung. __args__

Thuộc tính này là một

[1, 4, 9, 16, 25]
8994 (có thể có độ dài 1) của các loại chung được truyền cho
[1, 4, 9, 16, 25]
6256 ban đầu của lớp chung

[1, 4, 9, 16, 25]
614

tên chung. __tham số__

Thuộc tính này là một bộ được tính toán chậm (có thể trống) gồm các biến loại duy nhất được tìm thấy trong

[1, 4, 9, 16, 25]
6302

[1, 4, 9, 16, 25]
615

Ghi chú

Một đối tượng

[1, 4, 9, 16, 25]
6248 với các tham số
[1, 4, 9, 16, 25]
6360 có thể không đúng với
[1, 4, 9, 16, 25]
6361 sau khi thay thế vì
[1, 4, 9, 16, 25]
6360 chủ yếu dành cho kiểm tra kiểu tĩnh

tên chung. __unpacked__

Một giá trị boolean đúng nếu bí danh đã được giải nén bằng cách sử dụng toán tử

[1, 4, 9, 16, 25]
9000 (xem
[1, 4, 9, 16, 25]
6364)

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

Xem thêm

PEP 484 - Gợi ý loại

Giới thiệu khung của Python cho các chú thích loại

PEP 585 - Nhập gợi ý Generics trong bộ sưu tập tiêu chuẩn

Giới thiệu khả năng tham số hóa các lớp thư viện tiêu chuẩn, miễn là chúng triển khai phương thức lớp đặc biệt

[1, 4, 9, 16, 25]
6256

Thuốc chung , Thuốc chung do người dùng định nghĩa
[1, 4, 9, 16, 25]
6366

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¶

Đối tượng hợp lưu giữ giá trị của phép toán

[1, 4, 9, 16, 25]
6367 (theo bit hoặc) trên nhiều đối tượng loại . Các loại này chủ yếu dành cho chú thích loại . Biểu thức kiểu kết hợp cho phép cú pháp gợi ý kiểu sạch hơn so với
[1, 4, 9, 16, 25]
6368.

X . Y . .

Xác định một đối tượng kết hợp chứa các loại X, Y, v.v.

[1, 4, 9, 16, 25]
6369 có nghĩa là X hoặc Y. Nó tương đương với
[1, 4, 9, 16, 25]
6370. Ví dụ: hàm sau mong đợi một đối số kiểu
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501 hoặc
numbers = [1, 2, 3, 4, 5]

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
502

[1, 4, 9, 16, 25]
616

union_object == khác

Các đối tượng kết hợp có thể được kiểm tra sự bình đẳng với các đối tượng kết hợp khác. Thông tin chi tiết

  • Liên minh công đoàn bị san bằng

    [1, 4, 9, 16, 25]
    617

  • Các loại dư thừa được loại bỏ

    [1, 4, 9, 16, 25]
    618

  • Khi so sánh các công đoàn, thứ tự bị bỏ qua

    [1, 4, 9, 16, 25]
    619

  • Nó tương thích với

    [1, 4, 9, 16, 25]
    6368

    [1, 4, 9, 16, 25]
    620

  • Các loại tùy chọn có thể được viết dưới dạng hợp nhất với

    [1, 4, 9, 16, 25]
    631

    [1, 4, 9, 16, 25]
    621

isinstance(obj, union_object)issubclass(obj, union_object)

Các cuộc gọi đến

[1, 4, 9, 16, 25]
6293 và
[1, 4, 9, 16, 25]
6294 cũng được hỗ trợ với một đối tượng hợp nhất

[1, 4, 9, 16, 25]
622

Tuy nhiên, không thể sử dụng các đối tượng hợp có chứa các tổng quát được tham số hóa .

[1, 4, 9, 16, 25]
623

Loại người dùng tiếp xúc cho đối tượng hợp nhất có thể được truy cập từ

[1, 4, 9, 16, 25]
6377 và được sử dụng để kiểm tra
[1, 4, 9, 16, 25]
6293. Một đối tượng không thể được khởi tạo từ loại

[1, 4, 9, 16, 25]
624

Ghi chú

Phương thức

[1, 4, 9, 16, 25]
6379 cho các đối tượng kiểu đã được thêm vào để hỗ trợ cú pháp
[1, 4, 9, 16, 25]
6369. Nếu một siêu dữ liệu triển khai
[1, 4, 9, 16, 25]
6379, Liên minh có thể ghi đè lên nó

[1, 4, 9, 16, 25]
625

Xem thêm

PEP 604 – PEP đề xuất cú pháp

[1, 4, 9, 16, 25]
6369 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.

[1, 4, 9, 16, 25]
6383, 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
[1, 4, 9, 16, 25]
6384 nói đúng ra không phải là một thao tác trên đối tượng mô-đun;
[1, 4, 9, 16, 25]
6385 không yêu cầu đối tượng mô-đun có tên foo tồn tại, thay vào đó, nó yêu cầu định nghĩa (bên ngoài) cho mô-đun có tên foo ở đâu đó. )

Một thuộc tính đặc biệt của mọi mô-đun là

[1, 4, 9, 16, 25]
6386. Đây là từ điển chứa bảng ký hiệu của module. Việc 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
[1, 4, 9, 16, 25]
6386 (bạn có thể viết
[1, 4, 9, 16, 25]
6388, định nghĩa
[1, 4, 9, 16, 25]
6389 là
[1, 4, 9, 16, 25]
655, nhưng bạn không thể viết
[1, 4, 9, 16, 25]
6391). Không nên sửa đổi trực tiếp
[1, 4, 9, 16, 25]
6386

Các mô-đun được tích hợp trong trình thông dịch được viết như thế này.

[1, 4, 9, 16, 25]
6393. Nếu được tải từ một tệp, chúng được viết là
[1, 4, 9, 16, 25]
6394

Lớp và thực thể lớp¶

Xem Đối tượng, giá trị và loạiĐịnh nghĩa lớp .

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

[1, 4, 9, 16, 25]
6395

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 xác định. 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 Định nghĩa hàm để 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ư

[1, 4, 9, 16, 25]
6396 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ố

[1, 4, 9, 16, 25]
6397 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.
[1, 4, 9, 16, 25]
6398 là đối tượng mà phương thức hoạt động và
[1, 4, 9, 16, 25]
6399 là hàm triển khai phương thức. Gọi
[1, 4, 9, 16, 25]
6400 hoàn toàn tương đương với gọi
[1, 4, 9, 16, 25]
6401

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 (

[1, 4, 9, 16, 25]
6402), 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 sẽ dẫn đến việc tăng
[1, 4, 9, 16, 25]
6403. Để đặ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

[1, 4, 9, 16, 25]
626

Xem Hệ thống phân cấp loại tiêu chuẩn để 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 trả về bởi hàm

[1, 4, 9, 16, 25]
6404 tích hợp và có thể được trích xuất từ ​​các đối tượng hàm thông qua thuộc tính
[1, 4, 9, 16, 25]
6405 của chúng. Xem thêm mô-đun
[1, 4, 9, 16, 25]
6406

Việc truy cập vào

[1, 4, 9, 16, 25]
6405 sẽ tạo ra một sự kiện kiểm tra
[1, 4, 9, 16, 25]
6408 với các đối số
[1, 4, 9, 16, 25]
6409 và
[1, 4, 9, 16, 25]
6410.

Một đối tượng mã có thể được thực thi hoặc đánh giá bằng cách chuyển đối tượng đó (thay vì chuỗi nguồn) tới các hàm tích hợp

[1, 4, 9, 16, 25]
6411 hoặc
[1, 4, 9, 16, 25]
6412

Xem Hệ thống phân cấp loại tiêu chuẩn để biết thêm thông tin.

Nhập đố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ằng chức năng tích hợp sẵn

[1, 4, 9, 16, 25]
6413. Không có thao tác đặc biệt nào trên các loại. Mô-đun tiêu chuẩn
[1, 4, 9, 16, 25]
6414 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.

[1, 4, 9, 16, 25]
6415

Đố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, có tên là

[1, 4, 9, 16, 25]
631 (tên tích hợp).
[1, 4, 9, 16, 25]
6417 tạo ra cùng một singleton

Nó được viết là

[1, 4, 9, 16, 25]
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 Cắt lát ). 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ên là

[1, 4, 9, 16, 25]
6419 (tên tích hợp).
[1, 4, 9, 16, 25]
6420 tạo ra đĩa đơn
[1, 4, 9, 16, 25]
6419.

Nó được viết là

[1, 4, 9, 16, 25]
6419 hoặc
[1, 4, 9, 16, 25]
6423

Đố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 So sánh để biết thêm thông tin. Có chính xác một đối tượng

[1, 4, 9, 16, 25]
6424.
[1, 4, 9, 16, 25]
6425 tạo ra cá thể đơn lẻ.

Nó được viết là

[1, 4, 9, 16, 25]
6424

Giá trị Boolean¶

Giá trị Boolean là hai đối tượng hằng số

[1, 4, 9, 16, 25]
638 và
[1, 4, 9, 16, 25]
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. Có thể sử dụng hàm tích hợp sẵn
[1, 4, 9, 16, 25]
6429 để 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 Kiểm tra giá trị thực above).

Chúng được viết lần lượt là

[1, 4, 9, 16, 25]
638 và
[1, 4, 9, 16, 25]
656

Đối tượng bên trong¶

Xem Hệ thống phân cấp loại tiêu chuẩn để biết 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 hàm tích hợp sẵn

[1, 4, 9, 16, 25]
6432 báo cáo

đố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. __bases__

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

The tên đủ điều kiện của lớp, hàm, phương thức, bộ mô tả hoặc thể hiện 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

[1, 4, 9, 16, 25]
6433

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. Thí dụ

[1, 4, 9, 16, 25]
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 cho việc chuyển đổi giữa

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501 và
[1, 4, 9, 16, 25]
9022 để 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 ________ 9501 trong Python là một số có độ dài tùy ý được lưu trữ ở dạng nhị phân (thường được gọi là “bignum”). Không tồn tại thuật toán nào có thể chuyển đổi một chuỗi thành một số nguyên nhị phân hoặc một số nguyên nhị phân thành một chuỗi trong thời gian tuyến tính, trừ khi cơ số là lũy thừa của 2. Ngay cả các thuật toán được biết đến nhiều nhất cho cơ số 10 cũng có độ phức tạp bậc hai. Chuyển đổi một giá trị lớn chẳng hạn như

[1, 4, 9, 16, 25]
6437 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, một

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
577 được nâng lên

[1, 4, 9, 16, 25]
628

Giới hạn mặc định là 4300 chữ số như được cung cấp trong

[1, 4, 9, 16, 25]
6439. Giới hạn thấp nhất có thể được định cấu hình là 640 chữ số như được cung cấp trong
[1, 4, 9, 16, 25]
6440

xác minh

[1, 4, 9, 16, 25]
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

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

def square(number):
    return number ** 2

squared_nums = map(square, numbers)
print(list(squared_nums))
501 và
[1, 4, 9, 16, 25]
9022 hoặc
[1, 4, 9, 16, 25]
9023

  • [1, 4, 9, 16, 25]
    6444 với cơ số mặc định là 10

  • [1, 4, 9, 16, 25]
    6445 cho tất cả các cơ số không phải là lũy thừa của 2

  • [1, 4, 9, 16, 25]
    6446

  • [1, 4, 9, 16, 25]
    6447

  • bất kỳ chuyển đổi chuỗi nào khác sang cơ số 10, ví dụ:

    [1, 4, 9, 16, 25]
    6448,
    [1, 4, 9, 16, 25]
    6449 hoặc
    [1, 4, 9, 16, 25]
    6450

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

  • [1, 4, 9, 16, 25]
    6445 với cơ số 2, 4, 8, 16 hoặc 32

  • [1, 4, 9, 16, 25]
    6452 và
    [1, 4, 9, 16, 25]
    6453

  • [1, 4, 9, 16, 25]
    6454,
    [1, 4, 9, 16, 25]
    6455,
    [1, 4, 9, 16, 25]
    6456

  • Ngôn ngữ nhỏ đặc tả định dạng cho các số hex, bát phân và nhị phân.

  • [1, 4, 9, 16, 25]
    9022 đến
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    502

  • [1, 4, 9, 16, 25]
    9022 đến
    numbers = [1, 2, 3, 4, 5]
    
    def square(number):
        return number ** 2
    
    squared_nums = map(square, numbers)
    print(list(squared_nums))
    508

Đị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

  • [1, 4, 9, 16, 25]
    6461, e. g.
    [1, 4, 9, 16, 25]
    6462 để đặt giới hạn thành 640 hoặc
    [1, 4, 9, 16, 25]
    6463 để tắt giới hạn

  • [1, 4, 9, 16, 25]
    6464, e. g.
    [1, 4, 9, 16, 25]
    6465

  • [1, 4, 9, 16, 25]
    6466 chứa giá trị của
    [1, 4, 9, 16, 25]
    6461 hoặc
    [1, 4, 9, 16, 25]
    6464. Nếu cả tùy chọn env var và
    [1, 4, 9, 16, 25]
    6469 đều được đặt, thì tùy chọn
    [1, 4, 9, 16, 25]
    6469 sẽ được ưu tiên. Giá trị -1 cho biết rằng cả hai đều không được đặt, do đó, giá trị
    [1, 4, 9, 16, 25]
    6439 đã đượ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ách sử dụng các API

[1, 4, 9, 16, 25]
6472 này

  • [1, 4, 9, 16, 25]
    6473 và
    [1, 4, 9, 16, 25]
    6474 là công cụ khởi động và cài đặt giới hạn cho toàn bộ thông dịch viên. 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

[1, 4, 9, 16, 25]
6475

  • [1, 4, 9, 16, 25]
    6439 là giới hạn mặc định được biên dịch sẵn

  • [1, 4, 9, 16, 25]
    6440 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ậu 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 cứ lúc nào bản cập nhật

[1, 4, 9, 16, 25]
6478 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
[1, 4, 9, 16, 25]
8912 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

[1, 4, 9, 16, 25]
6480 thành tệp
[1, 4, 9, 16, 25]
6478

Cấu hình đề xuất¶

[1, 4, 9, 16, 25]
6439 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

Thí dụ

[1, 4, 9, 16, 25]
630

Nếu bạn cần tắt hoàn toàn, hãy đặt thành

[1, 4, 9, 16, 25]
642

chú thích

1

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 Hướng dẫn tham khảo Python ( Tùy chỉnh cơ bản ).

2

Kết quả là, danh sách

[1, 4, 9, 16, 25]
6484 được coi là bằng với
[1, 4, 9, 16, 25]
6485 và tương tự đối với các bộ dữ liệu

3

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(1,2,3,4)

Các ký tự viết hoa là những ký tự có thuộc tính danh mục chung là một trong số “Lu” (Chữ cái, chữ hoa), “Ll” (Chữ cái, chữ thường) hoặc “Lt” (Chữ cái, chữ hoa tiêu đề)

5(1,2)

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

Ánh xạ trong Python với ví dụ là gì?

Ánh xạ trong Python có nghĩa là áp dụng một thao tác cho từng phần tử của một lần lặp, chẳng hạn như danh sách . Ví dụ: hãy bình phương một danh sách các số bằng hàm map(). số = [1, 2, 3, 4, 5] squared_nums = map(lambda x. x ** 2, số) print(list(squared_nums))

một loại ánh xạ là gì?

Một đối tượng ánh xạ ánh xạ các giá trị của một loại (loại khóa) thành 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ạ, từ điển. Các khóa của từ điển gần như là các giá trị tùy ý.

Hàm ánh xạ trong Python là gì?

Bản đồ trong Python là hàm hoạt động như một trình lặp để trả về kết quả sau khi áp dụng một hàm cho mọi mục của một lần lặp (tuple, danh sách, v.v. ) . Nó được sử dụng khi bạn muốn áp dụng một hàm chuyển đổi duy nhất cho tất cả các phần tử có thể lặp lại. Hàm lặp và hàm được truyền dưới dạng đối số cho bản đồ trong Python.

Python có loại bản đồ không?

Python's map() là một chức năng tích hợp sẵn cho phép bạn xử lý và chuyển đổi tất cả các mục trong một lần lặp mà không cần sử dụng vòng lặp for rõ ràng , một kỹ thuật thường được gọi là ánh xạ. map() rất hữu ích khi bạn cần áp dụng hàm chuyển đổi cho từng mục trong một lần lặp và biến chúng thành một lần lặp mới.