Các loại tích hợp

Các phần sau đây mô tả các loại tiêu chuẩn được tích hợp trong trình thông dịch.

Các kiểu tích hợp chính là số, trình tự, ánh xạ, lớp, thể hiện và ngoại lệ.

Một số lớp sưu tập có thể thay đổi được. Các phương thức thêm, bớt 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 ngoại trừ None.

Một số thao tác được hỗ trợ bởi một số loại đối tượng; đặc biệt, trên thực tế, tất cả các đối tượng đều có thể được so sánh về sự bằng nhau, kiểm tra giá trị thực và được chuyển đổi thành một chuỗi (với hàm repr() hoặc hàm str() hơi khác một chút). Hàm sau được sử dụng ngầm khi một đối tượng được viết bởi hàm print().

Kiểm tra giá trị thật

Bất kỳ đối tượng nào cũng có thể được kiểm tra giá trị thực, để sử dụng trong điều kiện if hoặc while hoặc làm 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 __bool__() trả về False hoặc phương thức __len__() trả về 0 khi được gọi cùng với đối tượng. [1] Nếu một trong các phương thức đưa ra một ngoại lệ khi được gọi, ngoại lệ đó sẽ được truyền đi và đối tượng không có giá trị thật (ví dụ: NotImplemented). Dưới đây là hầu hết các đối tượng tích hợp được coi là sai:

• các hằng số được xác định là sai: None và False

• số không của bất kỳ loại số nào: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

• chuỗi và bộ sưu tập trống: '', (), [], {}, set(), range(0)

Các phép toán và hàm dựng sẵn có kết quả Boolean luôn trả về 0 hoặc False cho giá trị sai và 1 hoặc True cho giá trị đúng, trừ khi có quy định khác. (Ngoại lệ quan trọng: các phép toán Boolean or và and luôn trả về một trong các toán hạng của chúng.)

Các phép toán Boolean --- and, or, not

Đâ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ú
x or y	nếu x là đúng thì x, nếu không thì y	(1)
x and y	nếu x sai thì x, nếu không thì y	(2)
not x	nếu x sai thì True, nếu không thì False	(3)

Ghi chú:

1. Đây là toán tử đoản mạch nên nó chỉ đánh giá đối số thứ hai nếu đối số thứ nhất sai.

2. Đây là toán tử đoản mạch nên nó chỉ đánh giá đối số thứ hai nếu đối số thứ nhất đúng.

3. not có mức độ ưu tiên thấp hơn các toán tử không phải Boolean nên not a == b được hiểu là not (a == b) và a == not b là 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). Việc so sánh có thể được xâu chuỗi tùy ý; ví dụ: x < y <= z tương đương với x < y and y <= z, ngoại trừ việc y chỉ được đánh giá một lần (nhưng trong cả hai trường hợp, z hoàn toàn không được đánh giá khi x < y được phát hiện là sai).

Bảng này tóm tắt các hoạt động so sánh:

hoạt động	Ý nghĩa
<	đúng là ít hơn
<=	nhỏ hơn hoặc bằng
>	thực sự lớn hơn
>=	lớn hơn hoặc bằng
==	bằng nhau
!=	không bằng
is	nhận dạng đối tượng
is not	nhận dạng đối tượng bị phủ định

Trừ khi có quy định khác, các đối tượng thuộc các loại khác nhau không bao giờ so sánh bằng nhau. Toán tử == 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) thì tương đương với is. Các toán tử <, <=, > và >= chỉ được xác định khi chúng có ý nghĩa; ví dụ: họ đưa ra ngoại lệ TypeError khi một trong các đối số là số phức.

Các phiên bả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 __eq__().

Các phiên bản của một lớp không thể được sắp xếp theo các phiên bả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 đó xác định đủ các phương thức __lt__(), __le__(), __gt__() và __ge__() (nói chung, __lt__() và __eq__() là đủ, nếu bạn muốn hiểu ý nghĩa thông thường của các toán tử so sánh).

Không thể tùy chỉnh hành vi của các toán tử is và is not; Ngoài ra, chúng có thể được áp dụng cho bất kỳ hai đối tượng nào và không bao giờ đưa ra ngoại lệ.

Hai thao tác nữa có cùng mức độ ưu tiên cú pháp, in và not in, được hỗ trợ bởi các loại iterable hoặc triển khai phương thức __contains__().

Các loại số --- int, float, complex

Có ba loại số riêng biệt: integers, floating-point numbers và complex numbers. 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 double trong C; thông tin về độ chính xác và cách biểu diễn bên trong của các số dấu phẩy động cho máy mà chương trình của bạn đang chạy có sẵn trong sys.float_info. Số phức có phần thực và phần ảo, mỗi phần là một số có dấu phẩy động. Để trích xuất các phần này từ số phức z, hãy sử dụng z.real và z.imag. (Thư viện chuẩn bao gồm các kiểu số bổ sung fractions.Fraction, dành cho số hữu tỉ và decimal.Decimal, 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ằng các chữ số hoặc là kết quả của các hàm và toán tử tích hợp sẵn. Các chữ số nguyên không được trang trí (bao gồm số hex, số bát phân và số nhị phân) mang lại số nguyên. Các chữ số chứa dấu thập phân hoặc dấu mũ mang lại số dấu phẩy động. Việc thêm 'j' hoặc 'J' 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 số float để có được số phức có phần thực và phần ảo.

Các hàm tạo int(), float() và complex() có thể được sử dụng để tạo ra các số thuộc một loại cụ thể.

Python hỗ trợ đầy đủ số học hỗn hợp: khi toán tử số học nhị phân có toán hạng thuộc các kiểu số tích hợp khác nhau, toán hạng có kiểu "hẹp hơn" sẽ được mở rộng sang toán hạng kia:

• Nếu cả hai đối số đều là số phức thì không có chuyển đổi nào được thực hiện;

• nếu một trong hai đối số là số phức hoặc số dấu phẩy động thì đối số còn lại sẽ được chuyển thành số dấu phẩy động;

• mặt khác, cả hai đều phải là số nguyên và không cần chuyển đổi.

Số học với toán hạng phức và toán hạng thực được xác định bằng công thức toán học thông thường, ví dụ:

x + phức(u, v) = phức(x + u, v)
x * phức(u, v) = phức tạp(x * u, x * v)

Việc so sánh giữa các số thuộc các loại khác nhau hoạt động như thể giá trị chính xác của các số đó đang được so sánh. [2]

Tất cả các loại số (ngoại trừ số phức) đều hỗ trợ các thao tác sau (để biết mức độ ưu tiên của các thao tác, hãy xem Ưu tiên toán tử):

hoạt động	kết quả	Ghi chú	Tài liệu đầy đủ
x + y	tổng của x và y
x - y	sự khác biệt giữa x và y
x * y	sản phẩm của x và y
x / y	thương của x và y
x // y	thương số nổi của x và y	(1)(2)
x % y	phần còn lại của x / y	(2)
-x	x phủ định
+x	x không thay đổi
abs(x)	giá trị tuyệt đối hoặc độ lớn của x		abs()
int(x)	x chuyển đổi thành số nguyên	(3)(6)	int()
float(x)	x được chuyển đổi thành dấu phẩy động	(4)(6)	float()
complex(re, im)	số phức có phần thực re, phần ảo im. im mặc định là 0.	(6)	complex()
c.conjugate()	liên hợp của số phức c
divmod(x, y)	cặp đôi (x // y, x % y)	(2)	divmod()
pow(x, y)	x tăng sức mạnh y	(5)	pow()
x ** y	x tăng sức mạnh y	(5)

Ghi chú:

1. Còn được gọi là phép chia số nguyên. Đối với toán hạng kiểu int, kết quả có kiểu int. Đối với toán hạng kiểu float, kết quả có kiểu float. Nói chung, kết quả là một số nguyên 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: 1//2 là 0, (-1)//2 là -1, 1//(-2) là -1 và (-1)//(-2) là 0.

2. Không dành cho số phức. Thay vào đó hãy chuyển đổi sang float bằng abs() nếu thích hợp.

3. Chuyển đổi từ float sang int cắt ngắn, loại bỏ phần phân số. Xem các hàm math.floor() và math.ceil() để biết các chuyển đổi thay thế.

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 pow(0, 0) và 0 ** 0 là 1, như thông lệ đố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ố từ 0 đến 9 hoặc bất kỳ ký tự Unicode tương đương nào (điểm mã có thuộc tính Nd).

   Xem the Unicode Standard để biết danh sách đầy đủ các điểm mã với thuộc tính Nd.

Tất cả các loại numbers.Real (int và float) cũng bao gồm các thao tác sau:

hoạt động	kết quả
math.trunc(x)	x bị cắt ngắn thành Integral
round(x[, n])	x được làm tròn đến các chữ số n, làm tròn một nửa thành số chẵn. Nếu n bị bỏ qua, nó mặc định là 0.
math.floor(x)	Integral vĩ đại nhất <= x
math.ceil(x)	ít nhất là Integral >= x

Để biết thêm các thao tác số, hãy xem mô-đun math và cmath.

Hoạt động theo bit 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 phép toán theo bit được tính toán như thể được thực hiện theo phần bù hai với số lượng bit dấu vô hạn.

Mức độ ưu tiên của các phép toán theo bit 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; phép toán một ngôi ~ có cùng mức độ ưu tiên như các phép toán số một ngôi khác (+ và -).

Bảng này liệt kê các hoạt động theo bit được sắp xếp theo mức độ ưu tiên tăng dần:

hoạt động	kết quả	Ghi chú
x | y	bitwise or của x và y	(4)
x ^ y	bitwise exclusive or của x và y	(4)
x & y	bitwise and của x và y	(4)
x << n	x dịch chuyển sang trái n bit	(1)(2)
x >> n	x dịch chuyển sang phải n bit	(1)(3)
~x	các bit của x bị đảo ngược

Ghi chú:

1. Số lượng dịch chuyển âm là bất hợp pháp và khiến ValueError tăng lên.

2. Phép dịch trái với các bit n tương đương với phép nhân với pow(2, n).

3. Sự dịch chuyển sang phải theo các bit n tương đương với việc chia sàn cho pow(2, n).

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 bổ sung trong biểu diễn phần bù hai hữu hạn (độ rộng bit hoạt động là 1 + max(x.bit_length(), y.bit_length()) trở lên) là đủ để nhận đượ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 triển khai numbers.Integral abstract base class. 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 đứng đầu:

>>> n = -37
>>> thùng(n)
'-0b100101'
>>> n.bit_length()
6

Chính xác hơn, nếu x khác 0 thì x.bit_length() là số nguyên dương duy nhất k sao cho 2**(k-1) <= abs(x) < 2**k. Tương tự, khi abs(x) đủ nhỏ để có logarit được làm tròn chính xác thì k = 1 + int(log(abs(x), 2)). Nếu x bằng 0 thì x.bit_length() trả về 0.

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

def bit_length(tự):
    s = bin(self) đại diện # binary: bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove các số 0 ở đầu và dấu trừ
    trả về (các) len # len('100101') --> 6

Added in version 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. Điều này còn được gọi là số lượng dân số. Ví dụ:

>>> n = 19
>>> thùng(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

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

def bit_count(tự):
    return bin(self).count("1")

Added in version 3.10.

int.to_bytes(length=1, byteorder='big', *, signed=False)

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

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

Số nguyên được biểu thị bằng byte length và mặc định là 1. OverflowError được tăng lên nếu số nguyên không thể biểu thị được với số byte đã cho.

Đối số byteorder xác định thứ tự byte được sử dụng để biểu thị số nguyên và mặc định là "big". Nếu byteorder là "big" thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu byteorder là "little" thì byte quan trọng nhất nằm ở cuối mảng byte.

Đối số signed xác định xem phần bù hai có được sử dụng để biểu thị số nguyên hay không. Nếu signed là False và cho một số nguyên âm thì OverflowError sẽ được nâng lên. Giá trị mặc định cho signed là False.

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

>>> (65).to_bytes()
b'A'

Tuy nhiên, khi sử dụng các đối số mặc định, đừng cố chuyển đổi giá trị lớn hơn 255, nếu không bạn sẽ nhận được OverflowError.

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

def to_bytes(n, length=1, byteorder='big', signature=False):
    nếu byteorder == 'nhỏ':
        thứ tự = phạm vi (chiều dài)
    Elif byteorder == 'lớn':
        thứ tự = đảo ngược (phạm vi (độ dài))
    khác:
        raise ValueError("thứ tự byte phải là 'nhỏ' hoặc 'lớn'")

    trả về byte((n >> i*8) & 0xff cho i theo thứ tự)

Added in version 3.2.

Thay đổi trong phiên bản 3.11: Đã thêm giá trị đối số mặc định cho length và byteorder.

classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)

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

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Đối số bytes phải là bytes-like object hoặc tạo byte 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à "big". Nếu byteorder là "big" thì byte quan trọng nhất nằm ở đầu mảng byte. Nếu byteorder là "little" 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 sys.byteorder làm giá trị thứ tự byte.

Đối số signed cho biết liệu phần bù hai có được sử dụng để biểu thị số nguyên hay không.

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

def from_bytes(byte, byteorder='big', signature=False):
    nếu byteorder == 'nhỏ':
        little_ordered = danh sách (byte)
    Elif byteorder == 'lớn':
        little_ordered = danh sách (đảo ngược (byte))
    khác:
        raise ValueError("thứ tự byte phải là 'nhỏ' hoặc 'lớn'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    nếu đã ký và little_ordered và (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    trả lại n

Added in version 3.2.

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

int.as_integer_ratio()

Trả về một cặp số nguyên có tỷ số 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 làm mẫu số.

Added in version 3.8.

int.is_integer()

Trả về True. Tồn tại khả năng tương thích loại vịt với float.is_integer().

Added in version 3.12.

Phương pháp bổ sung trên Float

Kiểu float thực hiện numbers.Real abstract base class. float cũng có các phương thức bổ sung sau.

classmethod float.from_number(x)

Phương thức lớp để trả về số dấu phẩy động được xây dựng từ số x.

Nếu đối số là số nguyên hoặc số dấu phẩy động, thì số dấu phẩy động có cùng giá trị (trong độ chính xác dấu phẩy động của Python) sẽ được trả về. Nếu đối số nằm ngoài phạm vi của float Python, OverflowError sẽ được nâng lên.

Đối với một đối tượng Python chung x, float.from_number(x) ủy quyền cho x.__float__(). Nếu __float__() không được xác định thì nó sẽ quay trở lại __index__().

Added in version 3.14.

float.as_integer_ratio()

Trả về một cặp số nguyên có tỷ số chính xác bằng số float ban đầu. Tỷ lệ này ở dạng thấp nhất và có mẫu số dương. Tăng OverflowError ở vô số và ValueError trên NaN.

float.is_integer()

Trả về True nếu phiên bản float hữu hạn với giá trị tích phân và False nếu ngược lại:

>>> (-2.0).is_integer()
đúng
>>> (3.2).is_integer()
sai

Hai phương pháp hỗ trợ chuyển đổi sang và từ chuỗi thập lục phân. Vì số float của Python được lưu trữ nội bộ dưới dạng số nhị phân, nên việc chuyển đổi float sang hoặc từ chuỗi decimal thường gây ra một lỗi làm tròn nhỏ. Ngược lại, 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ố có dấu phẩy động. Điều này có thể hữu ích khi gỡ lỗi và trong công việc tính toán.

float.hex()

Trả về biểu diễn của số dấu phẩy động dưới dạng chuỗi thập lục phân. Đối với các số có dấu phẩy động hữu hạn, biểu diễn này sẽ luôn bao gồm một 0x ở đầu và một p ở cuối và số mũ.

classmethod float.fromhex(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 float.hex() là một phương thức phiên bản, trong khi float.fromhex() là một phương thức lớp.

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

[dấu] ['0x'] số nguyên ['.' phân số] ['p' số mũ]

trong đó sign tùy chọn có thể là + hoặc -, integer và fraction là các chuỗi chữ số thập lục phân và exponent là số nguyên thập phân có dấu đầu dòng tùy chọn. Chữ hoa chữ thường không có ý nghĩa 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 được chỉ định trong phần 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 float.hex() có thể được sử dụng dưới dạng chữ có 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 %a của C hoặc Double.toHexString của Java đều được float.fromhex() chấp nhận.

Lưu ý rằng số mũ được viết ở dạng thập phân chứ không phải thập lục phân và nó có lũy thừa bằng 2 để nhân hệ số. Ví dụ: chuỗi thập lục phân 0x3.a7p10 đại diện cho số dấu phẩy động (3 + 10./16 + 7./16**2) * 2.0**10 hoặc 3740.0:

>>> float.fromhex('0x3.a7p10')
3740,0

Áp dụng chuyển đổi ngược lại cho 3740.0 sẽ tạo ra một chuỗi thập lục phân khác biểu thị cùng một số

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

Các phương pháp bổ sung trên Complex

Loại complex triển khai numbers.Complex abstract base class. complex còn có các phương thức bổ sung sau.

classmethod complex.from_number(x)

Phương thức lớp để chuyển đổi một số thành số phức.

Đối với một đối tượng Python chung x, complex.from_number(x) ủy quyền cho x.__complex__(). Nếu __complex__() không được xác định thì nó sẽ quay trở lại __float__(). Nếu __float__() không được xác định thì nó sẽ quay trở lại __index__().

Added in version 3.14.

Băm các kiểu số

Đối với các số x và y, có thể thuộc các loại khác nhau, yêu cầu hash(x) == hash(y) bất cứ khi nào x == y (xem tài liệu về phương pháp __hash__() để biết thêm chi tiết). Để dễ triển khai và hiệu quả trên nhiều loại số khác nhau (bao gồm int, float, decimal.Decimal và fractions.Fraction), 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 int và fractions.Fraction cũng như tất cả các phiên bản hữu hạn của float và decimal.Decimal. Về cơ bản, hàm này được đưa ra bằng cách rút gọn modulo P cho số nguyên tố P cố định. Giá trị của P được cung cấp cho Python dưới dạng thuộc tính modulus của sys.hash_info.

Hiện tại, mã cơ bản được sử dụng là P = 2**31 - 1 trên các máy có độ dài C 32 bit và P = 2**61 - 1 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 x = m / n là số hữu tỉ không âm và n không chia hết cho P, hãy xác định hash(x) là m * invmod(n, P) % P, trong đó invmod(n, P) cho nghịch đảo của n modulo P.

• Nếu x = m / n là số hữu tỉ không âm và n chia hết cho P (nhưng m thì không) thì n không có modulo nghịch đảo P và quy tắc trên không áp dụng; trong trường hợp này xác định hash(x) là giá trị không đổi sys.hash_info.inf.

• Nếu x = m / n là số hữu tỷ âm, hãy xác định hash(x) là -hash(-x). Nếu kết quả băm là -1, hãy thay thế nó bằng -2.

• Các giá trị cụ thể sys.hash_info.inf và -sys.hash_info.inf đượ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ố complex z, 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 hash(z.real) + sys.hash_info.imag * hash(z.imag), giảm modulo 2**sys.hash_info.width để nó nằm trong range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). Một lần nữa, nếu kết quả là -1, nó sẽ được thay thế bằng -2.

Để làm rõ các quy tắc trên, đây là một số mã Python mẫu, 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ỷ, float hoặc complex:

nhập hệ thống, toán học

def hash_phân số (m, n):
    """Tính hàm băm của số hữu tỷ m / n.

    Giả sử m và n là số nguyên, với n dương.
    Tương đương với hàm băm(phân số.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove là thừa số chung của P. (Không cần thiết nếu m và n nguyên tố cùng nhau.)
    trong khi m % P == n % P == 0:
        m, n = m // P, n // P

    nếu n% P == 0:
        giá trị băm = sys.hash_info.inf
    khác:
        Định lý nhỏ của # Fermat: pow(n, P-1, P) là 1, vậy
        # pow(n, P-2, P) cho nghịch đảo của n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    nếu m < 0:
        giá trị băm = -hash_value
    nếu giá trị băm == -1:
        giá trị băm = -2
    trả về giá trị băm

def hash_float(x):
    """Tính hàm băm của float x."""

    nếu math.isnan(x):
        trả về đối tượng.__hash__(x)
    Elif math.isinf(x):
        trả về sys.hash_info.inf nếu x > 0 khác -sys.hash_info.inf
    khác:
        trả về hàm băm_phân số(*x.as_integer_ratio())

def hash_complex(z):
    """Tính hàm băm của số phức z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do một modulo giảm đã ký 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    giá trị băm = (giá trị băm & (M - 1)) - (giá trị băm & M)
    nếu giá trị băm == -1:
        giá trị băm = -2
    trả về giá trị băm

Kiểu Boolean - bool

Booleans đại diện cho giá trị chân lý. Loại bool có chính xác hai phiên bản không đổi: True và False.

Hàm tích hợp bool() 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ật ở trên).

Đối với các hoạt động logic, hãy sử dụng boolean operators and, or và not. Khi áp dụng các toán tử bitwise &, |, ^ cho hai boolean, chúng trả về một bool tương đương với các phép toán logic "và", "hoặc", "xor". Tuy nhiên, các toán tử logic and, or và != nên được ưu tiên hơn &, | và ^.

Sắp loại bỏ từ phiên bản 3.12: Việc sử dụng toán tử đảo ngược bit ~ không được dùng nữa và sẽ gây ra lỗi trong Python 3.16.

bool là một lớp con của int (xem Các loại số --- int, float, complex). Trong nhiều ngữ cảnh số, False và True hoạt động tương ứng giống như các số nguyên 0 và 1. Tuy nhiên, việc dựa vào điều này là không được khuyến khích; thay vào đó hãy chuyển đổi rõ ràng bằng cách sử dụng int().

Các loại vòng lặp

Python hỗ trợ khái niệm lặp qua các vùng chứa. Điều này được thực hiện bằng hai phương pháp riêng biệt; chúng được sử dụng để cho phép các lớp do người dùng định nghĩa hỗ trợ việc lặp lại. Các trình tự được mô tả chi tiết hơn dưới đây 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ợ iterable:

container.__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, các phương thức bổ sung có thể được cung cấp để 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 dạng 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à chiều sâu.) Phương thức này tương ứng với vị trí tp_iter của cấu trúc kiểu cho các đối tượng Python trong Python/C API.

Bản thân các đối tượng iterator được yêu cầu phải hỗ trợ hai phương thức sau, chúng cùng nhau tạo thành iterator protocol:

iterator.__iter__()

Trả về chính đối tượng iterator. Điều này là bắt buộc để cho phép sử dụng cả vùng chứa và trình vòng lặp với câu lệnh for và in. Phương thức này tương ứng với khe tp_iter của cấu trúc kiểu cho các đối tượng Python trong Python/C API.

iterator.__next__()

Trả lại mục tiếp theo từ iterator. Nếu không có mục nào nữa, hãy đưa ra ngoại lệ StopIteration. Phương thức này tương ứng với khe tp_iternext của cấu trúc kiểu cho các đối tượng Python trong Python/C API.

Python định nghĩa một số đối tượng iterator để hỗ trợ phép lặp trên các kiểu trình tự chung và cụ thể, từ điển và các dạng chuyên biệt 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 __next__() của iterator tăng StopIteration, nó phải tiếp tục làm như vậy trong các lệnh 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

generators của Python cung cấp một cách thuận tiện để triển khai giao thức vòng lặp. Nếu phương thức __iter__() của đối tượng vùng chứa được triển khai như một trình tạo, nó sẽ tự động trả về một đối tượng lặp (về mặt kỹ thuật là đối tượng trình tạo) cung cấp các phương thức __iter__() và __next__(). Thông tin thêm về máy phát điện có thể được tìm thấy trong the documentation for the yield expression.

Các loại trình tự --- list, tuple, range

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ý binary data và text strings được mô tả trong các phần dành riêng.

Hoạt động trình tự chung

Các thao tác 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. collections.abc.Sequence 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 thao tác 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 in và not in có cùng mức độ ưu tiên như các hoạt động so sánh. Các phép toán + (nối) và * (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ú
x in s	True nếu một mục của s bằng x, nếu không thì False	(1)
x not in s	False nếu một mục của s bằng x, nếu không thì True	(1)
s + t	sự kết hợp của s và t	(6)(7)
s * n hoặc n * s	tương đương với việc thêm s vào chính nó n lần	(2)(7)
s[i]	imục thứ của s, nguồn gốc 0	(3)(8)
s[i:j]	lát s từ i đến j	(3)(4)
s[i:j:k]	lát s từ i đến j với bước k	(3)(5)
len(s)	chiều dài của s
min(s)	mục nhỏ nhất của s
max(s)	mặt hàng lớn nhất của s

Trình tự cùng loại cũng hỗ trợ so sánh. Cụ thể, các bộ 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 chuỗi phải cùng loại và có cùng độ dài. (Để biết chi tiết đầy đủ, hãy xem So sánh trong 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 trên các giá trị truy cập chuỗi có thể thay đổi bằng cách sử dụng chỉ mục. Chỉ mục đó sẽ tiếp tục tiến lên (hoặc lùi lại) ngay cả khi chuỗi cơ bản bị thay đổi. Trình lặp chỉ kết thúc khi gặp IndexError hoặc StopIteration (hoặc khi chỉ số giảm xuống dưới 0).

Ghi chú:

1. Mặc dù các hoạt động in và not in chỉ được sử dụng để kiểm tra ngăn chặn đơn giản trong trường hợp chung, một số trình tự chuyên biệt (chẳng hạn như str, bytes và bytearray) cũng sử dụng chúng để kiểm tra trình tự tiếp theo:

   >>> "gg" trong "trứng"
   đúng
   

2. Các giá trị của n nhỏ hơn 0 được coi là 0 (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; chúng được tham chiếu nhiều lần. Điều này thường ám ảnh những lập trình viên Python mới; xem xét:

   >>> danh sách = [[]] * 3
   >>> danh sách
   [[], [], []]
   >>> danh sách[0].append(3)
   >>> danh sách
   [[3], [3], [3]]
   

   Điều đã xảy ra là [[]] 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 [[]] * 3 đề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 lists sẽ sửa đổi danh sách đơn này. Bạn có thể tạo danh sách các danh sách khác nhau theo cách này:

   >>> danh sách = [[] cho i trong phạm vi (3)]
   >>> danh sách[0].append(3)
   >>> danh sách[1].append(5)
   >>> danh sách[2].append(7)
   >>> danh sách
   [[3], [5], [7]]
   

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

3. Nếu i hoặc j âm, chỉ số tương ứng với phần cuối của chuỗi s: len(s) + i hoặc len(s) + j được thay thế. Nhưng lưu ý rằng -0 vẫn là 0.

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

   • Nếu i bị bỏ qua hoặc None, hãy sử dụng 0.

   • Nếu j bị bỏ qua hoặc None, hãy sử dụng len(s).

   • Nếu i hoặc j nhỏ hơn -len(s), hãy sử dụng 0.

   • Nếu i hoặc j lớn hơn len(s), hãy sử dụng len(s).

   • Nếu i lớn hơn hoặc bằng j thì lát cắt trống.

5. Lát cắ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ố x = i + n*k sao cho 0 <= n < (j-i)/k. Nói cách khác, các chỉ số là i, i+k, i+2*k, i+3*k, 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 giảm xuống len(s) nếu chúng lớn hơn. Khi k âm, i và j giảm xuống len(s) - 1 nếu chúng lớn hơn. Nếu i hoặc j bị bỏ qua hoặc None, chúng sẽ trở thành giá trị "kết thúc" (kết thúc nào phụ thuộc vào dấu của k). Lưu ý, k không thể bằng 0. Nếu k là None thì nó được xử lý như 1.

6. Việc ghép 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 tính trên tổng độ dài chuỗi. Để có đượ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 str, bạn có thể tạo danh sách và sử dụng str.join() ở cuối hoặc ghi vào một phiên bản io.StringIO và truy xuất giá trị của nó khi hoàn thành

   • nếu ghép nối các đối tượng bytes, bạn có thể sử dụng tương tự bytes.join() hoặc io.BytesIO hoặc bạn có thể thực hiện ghép nối tại chỗ với đối tượng bytearray. Các đối tượng bytearray 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 tuple, thay vào đó hãy mở rộng list

   • đố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ư range) chỉ hỗ trợ các chuỗi mục 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. Một IndexError được nâng lên nếu i nằm ngoài phạm vi chuỗi.

Phương pháp trình tự

Các loại trình tự cũng hỗ trợ các phương pháp sau:

sequence.count(value, /)

Trả về tổng số lần xuất hiện của value trong sequence.

sequence.index(value[, start[, stop]])

Trả về chỉ mục lần xuất hiện đầu tiên của value trong sequence.

Tăng ValueError nếu không tìm thấy value trong sequence.

Các đối số start hoặc stop cho phép tìm kiếm hiệu quả các phần phụ của chuỗi, bắt đầu tại start và kết thúc tại stop. Điều này gần tương đương với start + sequence[start:stop].index(value), chỉ không sao chép bất kỳ dữ liệu nào.

Cảnh báo

Không phải tất cả các loại trình tự đều hỗ trợ truyền đối số start và stop.

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

Hoạt động duy nhất mà các loại trình tự bất biến thường triển khai mà các loại trình tự có thể thay đổi cũng không triển khai là hỗ trợ cho hash() tích hợp sẵn.

Sự hỗ trợ này cho phép các chuỗi bất biến, chẳng hạn như phiên bản tuple, được sử dụng làm khóa dict và được lưu trữ trong các phiên bản set và frozenset.

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 sẽ dẫn đến TypeError.

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. collections.abc.MutableSequence 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 phiên bản của loại chuỗi có thể thay đổi, t là bất kỳ đối tượng có thể lặp lại nào và x là một đối tượng tùy ý đáp ứng mọi hạn chế về loại và giá trị do s áp đặt (ví dụ: bytearray chỉ chấp nhận các số nguyên đáp ứng hạn chế giá trị 0 <= x <= 255).

hoạt động	kết quả	Ghi chú
s[i] = x	mục i của s được thay thế bằng x
del s[i]	xóa mục i của s
s[i:j] = t	lát s từ i đến j được thay thế bằng nội dung của t có thể lặp lại
del s[i:j]	xóa các phần tử của s[i:j] khỏi danh sách (giống như s[i:j] = [])
s[i:j:k] = t	các phần tử của s[i:j:k] được thay thế bằng các phần tử của t	(1)
del s[i:j:k]	xóa các phần tử của s[i:j:k] khỏi danh sách
s += t	mở rộng s với nội dung của t (phần lớn giống với s[len(s):len(s)] = t)
s *= n	cập nhật s với nội dung được lặp lại n lần	(2)

Ghi chú:

1. Nếu k không bằng 1 thì t phải có cùng độ dài với lát cắt mà nó đang thay thế.

2. Giá trị n là một số nguyên hoặc một đối tượng triển khai __index__(). 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; chúng được tham chiếu nhiều lần, như được giải thích cho s * n trong Hoạt động trình tự chung.

Phương pháp trình tự có thể thay đổi

Các loại trình tự có thể thay đổi cũng hỗ trợ các phương pháp sau:

sequence.append(value, /)

Nối value vào cuối chuỗi. Điều này tương đương với việc viết seq[len(seq):len(seq)] = [value].

sequence.clear()

Added in version 3.3.

Xóa tất cả các mục khỏi sequence. Điều này tương đương với việc viết del sequence[:].

sequence.copy()

Added in version 3.3.

Tạo một bản sao nông của sequence. Điều này tương đương với việc viết sequence[:].

Gợi ý

Phương thức copy() không phải là một phần của MutableSequence ABC, nhưng hầu hết các loại trình tự có thể thay đổi cụ thể đều cung cấp nó.

sequence.extend(iterable, /)

Mở rộng sequence với nội dung của iterable. Đối với hầu hết các trường hợp, điều này cũng giống như viết seq[len(seq):len(seq)] = iterable.

sequence.insert(index, value, /)

Chèn value vào sequence tại index đã cho. Điều này tương đương với việc viết sequence[index:index] = [value].

sequence.pop(index=-1, /)

Truy xuất mục tại index và cũng xóa mục đó khỏi sequence. Theo mặc định, mục cuối cùng trong sequence sẽ bị xóa và trả lại.

sequence.remove(value, /)

Xóa mục đầu tiên khỏi sequence trong đó sequence[i] == value.

Tăng ValueError nếu không tìm thấy value trong sequence.

sequence.reverse()

Đảo ngược các mục của sequence tại chỗ. Phương pháp này duy trì tính kinh tế về không gian khi đảo ngược một chuỗi lớn. Để nhắc nhở người dùng rằng nó hoạt động theo tác dụng phụ, nó trả về None.

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

class list(iterable=(), /)

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: []

• Sử dụng dấu ngoặc vuông, ngăn cách các mục bằng dấu phẩy: [a], [a, b, c]

• Sử dụng khả năng hiểu danh sách: [x for x in iterable]

• Sử dụng hàm tạo kiểu: list() hoặc list(iterable)

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ả về, tương tự như iterable[:]. Ví dụ: list('abc') trả về ['a', 'b', 'c'] và list( (1, 2, 3) ) trả về [1, 2, 3]. 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, [].

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

Danh sách thực hiện tất cả các hoạt động chuỗi common và mutable. Danh sách cũng cung cấp phương pháp bổ sung sau:

sort(*, key=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 < giữa các mục. Các ngoại lệ không bị loại bỏ - nếu bất kỳ thao tác so sánh nào không thành công thì toàn bộ thao tác sắp xếp sẽ không thành công (và danh sách có thể sẽ bị giữ ở trạng thái được sửa đổi một phần).

sort() chấp nhận hai đối số chỉ có thể được truyền bằng từ khóa (keyword-only arguments):

key chỉ định hàm 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ụ: key=str.lower). Khóa tương ứng với từng mục trong danh sách được tính một lần rồi sử dụng cho toàn bộ quá trình sắp xếp. Giá trị mặc định của None có nghĩa là các mục trong danh sách được sắp xếp trực tiếp mà không tính toán giá trị khóa riêng.

Tiện ích functools.cmp_to_key() có sẵn để chuyển đổi hàm cmp kiểu 2.x thành hàm key.

reverse là giá trị boolean. Nếu được đặt thành True thì các thành phần trong danh sách sẽ được sắp xếp như thể mỗi 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 chuỗi 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ự đã sắp xếp (sử dụng sorted() để yêu cầu rõ ràng một phiên bản danh sách được sắp xếp mới).

Phương pháp sort() được đảm bảo ổn định. Một cách 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ử so sánh bằng nhau --- điều này rất 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 cấp lương).

Để biết các ví dụ về sắp xếp và hướng dẫn sắp xếp ngắn gọn, hãy xem Kỹ thuật sắp xếp.

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 là không xác định. Việc triển khai C của Python làm cho danh sách có vẻ trống trong suốt thời gian và tăng ValueError 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.

Xem thêm

Để biết thông tin chi tiết về đảm bảo an toàn luồng cho các đối tượng list, hãy xem An toàn chủ đề cho các đối tượng danh sách.

Bộ dữ liệu

Bộ dữ liệu là các chuỗi bất biến, thường được sử dụng để lưu trữ các tập hợp dữ liệu không đồng nhất (chẳng hạn như 2 bộ dữ liệu được tạo bởi enumerate() tích hợp). Bộ dữ liệu cũng được sử dụng trong 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 phiên bản set hoặc dict).

class tuple(iterable=(), /)

Bộ dữ liệu có thể được xây dựng theo một số cách:

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

• Sử dụng dấu phẩy ở cuối cho một bộ dữ liệu đơn: a, hoặc (a,)

• Tách các mục bằng dấu phẩy: a, b, c hoặc (a, b, c)

• Sử dụng tuple() tích hợp: tuple() hoặc tuple(iterable)

Hàm tạo xây dựng một bộ dữ liệu 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 bộ dữ liệu thì nó sẽ được trả về không thay đổi. Ví dụ: tuple('abc') trả về ('a', 'b', 'c') và tuple( [1, 2, 3] ) trả về (1, 2, 3). Nếu không có đối số nào được đưa ra, hàm tạo sẽ tạo một bộ trống mới, ().

Lưu ý rằng thực ra chính dấu phẩy tạo nên một bộ dữ liệu 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ừ trường hợp bộ dữ liệu trống hoặc khi chúng cần thiết để tránh sự mơ hồ về cú pháp. Ví dụ: f(a, b, c) là lệnh gọi hàm có ba đối số, trong khi f((a, b, c)) là lệnh gọi hàm có 3 bộ làm đối số duy nhất.

Các bộ dữ liệu thực hiện tất cả các hoạt động của chuỗi common.

Đối với các bộ sưu tập dữ liệu không đồng nhất trong đó việc truy cập theo tên rõ ràng hơn truy cập theo chỉ mục, collections.namedtuple() có thể là lựa chọn phù hợp hơn so với một đối tượng bộ dữ liệu đơn giản.

Phạm vi

Loại range đại diện cho một chuỗi 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 for.

class range(stop, /)

class range(start, stop, step=1, /)

Các đối số cho hàm tạo phạm vi phải là số nguyên (int tích hợp hoặc bất kỳ đối tượng nào triển khai phương thức đặc biệt __index__()). Nếu đối số step bị bỏ qua, nó sẽ mặc định là 1. Nếu đối số start bị bỏ qua, nó sẽ mặc định là 0. Nếu step bằng 0, ValueError được nâng lên.

Đối với step dương, nội dung của phạm vi r được xác định theo công thức r[i] = start + step*i trong đó i >= 0 và r[i] < stop.

Đối với step âm, nội dung của phạm vi vẫn được xác định theo công thức r[i] = start + step*i, nhưng các ràng buộc là i >= 0 và r[i] > stop.

Đối tượng phạm vi sẽ trống nếu r[0] không đáp ứng ràng buộc giá trị. Các 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.

Cho phép các phạm vi chứa giá trị tuyệt đối lớn hơn sys.maxsize nhưng một số tính năng (chẳng hạn như len()) có thể tăng OverflowError.

Ví dụ về phạm vi:

>>> danh sách (phạm vi (10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> danh sách (phạm vi (1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> danh sách(phạm vi(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> danh sách(phạm vi(0, 10, 3))
[0, 3, 6, 9]
>>> danh sách(phạm vi(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> danh sách (phạm vi (0))
[]
>>> danh sách (phạm vi (1, 0))
[]

Các phạm vi triển khai tất cả các thao tác chuỗi common 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 thị các chuỗi tuân theo một mẫu nghiêm ngặt và việc lặp lại và ghép nối thường sẽ vi phạm mẫu đó).

start

Giá trị của tham số start (hoặc 0 nếu tham số không được cung cấp)

stop

Giá trị của tham số stop

step

Giá trị của tham số step (hoặc 1 nếu tham số không được cung cấp)

Ưu điểm của loại range so với list hoặc tuple thông thường là đối tượng range 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ị start, stop và step, tính toán các mục riêng lẻ và các phạm vi con nếu cần).

Các đối tượng phạm vi triển khai collections.abc.Sequence 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ự --- list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Kiểm tra sự bằng nhau của các đối tượng phạm vi với == và != so sánh chúng dưới dạng chuỗi. 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 start, stop và step khác nhau, ví dụ: range(0) == range(2, 1, 3) hoặc range(0, 3, 2) == range(0, 4, 2).)

Thay đổi trong phiên bản 3.2: Triển khai Trình tự ABC. Hỗ trợ cắt và chỉ số tiêu cực. Kiểm tra tư cách thành viên của các đối tượng int 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 trong 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).

Đã thêm các thuộc tính start, stop và step.

Xem thêm

• Zz000zz 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.

Tóm tắt các phương pháp loại chuỗi nhị phân và văn bản

Bảng sau đây tóm tắt các phương pháp loại chuỗi văn bản và nhị phân theo danh mục.

Danh mục	phương pháp str				phương pháp bytes và bytearray
Định dạng	str.format()
	str.format_map()
	dây f
	Định dạng chuỗi kiểu printf				Định dạng byte kiểu printf
Tìm kiếm và thay thế	str.find()	str.rfind()			bytes.find()	bytes.rfind()
	str.index()	str.rindex()			bytes.index()	bytes.rindex()
	str.startswith()				bytes.startswith()
	str.endswith()				bytes.endswith()
	str.count()				bytes.count()
	str.replace()				bytes.replace()
Chia tách và tham gia	str.split()		str.rsplit()		bytes.split()		bytes.rsplit()
	str.splitlines()				bytes.splitlines()
	str.partition()				bytes.partition()
	str.rpartition()				bytes.rpartition()
	str.join()				bytes.join()
Phân loại chuỗi	str.isalpha()				bytes.isalpha()
	str.isdecimal()
	str.isdigit()				bytes.isdigit()
	str.isnumeric()
	str.isalnum()				bytes.isalnum()
	str.isidentifier()
	str.islower()				bytes.islower()
	str.isupper()				bytes.isupper()
	str.istitle()				bytes.istitle()
	str.isspace()				bytes.isspace()
	str.isprintable()
Thao tác trường hợp	str.lower()				bytes.lower()
	str.upper()				bytes.upper()
	str.casefold()
	str.capitalize()				bytes.capitalize()
	str.title()				bytes.title()
	str.swapcase()				bytes.swapcase()
Đệm và Tước	str.ljust()		str.rjust()		bytes.ljust()		bytes.rjust()
	str.center()				bytes.center()
	str.expandtabs()				bytes.expandtabs()
	str.strip()				bytes.strip()
	str.lstrip()			str.rstrip()	bytes.lstrip()			bytes.rstrip()
Dịch thuật và mã hóa	str.translate()				bytes.translate()
	str.maketrans()				bytes.maketrans()
	str.encode()
					bytes.decode()

Loại chuỗi văn bản --- str

Dữ liệu văn bản trong Python được xử lý bằng các đối tượng str hoặc strings. Chuỗi là sequences bất biến của các điểm mã Unicode. Chuỗi ký tự được viết theo nhiều cách khác nhau:

• Dấu ngoặc đơn: 'allows embedded "double" quotes'

• Dấu ngoặc kép: "allows embedded 'single' quotes"

• Trích dẫn ba lần: '''Three single quotes''', """Three double quotes"""

Chuỗi trích dẫn ba lần có thể trải dài trên nhiều dòng - tất cả khoảng trắng liên quan 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 đơn 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à, ("spam " "eggs") == "spam eggs".

Xem Chuỗi và byte bằng chữ để biết thêm về các dạng chuỗi ký tự khác nhau, bao gồm escape sequences được hỗ trợ và tiền tố r ("thô") vô hiệu hóa hầu hết quá trình xử lý chuỗi thoát.

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

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, s[0] == s[0:1].

Cũng không có loại chuỗi có thể thay đổi, nhưng str.join() hoặc io.StringIO có thể được sử dụng để xây dựng chuỗi từ nhiều đoạn một cách hiệu quả.

Thay đổi trong phiên bản 3.3: Để tương thích ngược với dòng Python 2, tiền tố u một lần nữa được cho phép trên các 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ố r.

class str(*, encoding='utf-8', errors='strict')

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

Trả về phiên bản string của object. Nếu object không được cung cấp, trả về chuỗi trống. Mặt khác, hành vi của str() phụ thuộc vào việc encoding hay errors được đưa ra, như sau.

Nếu cả encoding và errors đều không được cung cấp, str(object) sẽ trả về type(object).__str__(object), đây là dạng biểu diễn chuỗi "không chính thức" hoặc có thể in được của object. Đối với các đối tượng chuỗi, đây chính là chuỗi đó. Nếu object không có phương thức __str__() thì str() sẽ quay lại trả về repr(object).

Nếu có ít nhất một trong số encoding hoặc errors thì object phải là bytes-like object (ví dụ: bytes hoặc bytearray). Trong trường hợp này, nếu object là đối tượng bytes (hoặc bytearray), thì str(bytes, encoding, errors) tương đương với bytes.decode(encoding, errors). Mặt khác, đối tượng byte bên dưới đối tượng bộ đệm sẽ được lấy trước khi gọi bytes.decode(). Xem Các loại chuỗi nhị phân --- bytes, bytearray, memoryview và Giao thức đệm để biết thông tin về các đối tượng đệm.

Việc truyền một đối tượng bytes tới str() mà không có đối số encoding hoặc errors nằm trong 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 -b cho Python). Ví dụ:

>>> str(b'Zoot!')
"b'Zoot!'"

Để biết thêm thông tin về lớp str và các phương thức của nó, hãy xem phần Loại chuỗi văn bản --- str và Phương thức chuỗi bên dưới. Để xuất các chuỗi được định dạng, hãy xem phần dây f và Cú pháp định dạng chuỗi. Ngoài ra, hãy xem phần Dịch vụ xử lý văn bản.

Phương thức chuỗi

Các chuỗi triển khai tất cả các hoạt động của chuỗi common, 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 str.format(), Cú pháp định dạng chuỗi và Định dạng chuỗi tùy chỉnh) và kiểu kia dựa trên định dạng kiểu C printf xử lý phạm vi loại hẹp hơn và khó sử dụng chính xác hơn một chút, nhưng thường nhanh hơn trong các trường hợp nó có thể xử lý (Định dạng chuỗi kiểu printf).

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 mô-đun re).

str.capitalize()

Trả về một bản sao của chuỗi có 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 bây giờ đượ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 đóng hộp của chuỗi. Các chuỗi được xếp kiểu chữ hoa chữ thường có thể được sử dụng để so khớp không phân biệt chữ hoa chữ thường.

Viết hoa chữ thường tương tự như chữ thường nhưng mạnh mẽ 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ữ cái viết thường của Đức 'ß' tương đương với "ss". Vì nó đã là chữ thường nên lower() sẽ không làm gì với 'ß'; casefold() chuyển đổi nó thành "ss". Ví dụ:

>>> 'straße'.low()
'đường phố'
>>> 'straße'.casefold()
'strasse'

Thuật toán casefolding là described in section 3.13 'Default Case Folding' of the Unicode Standard.

Added in version 3.3.

str.center(width, fillchar=' ', /)

Trả về căn giữa trong chuỗi có độ dài width. Việc đệm được thực hiện bằng cách sử dụng fillchar được chỉ định (mặc định là khoảng trắng ASCII). Chuỗi gốc được trả về nếu width nhỏ hơn hoặc bằng len(s). Ví dụ:

>>> 'Python'.center(10)
' Python'
>>> 'Python'.center(10, '-')
'--Python--'
>>> 'Python'.center(4)
'Trăn'

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

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

Nếu sub 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. Ví dụ:

>>> 'thư rác, thư rác, thư rác'.count('spam')
3
>>> 'thư rác, thư rác, thư rác'.count('spam', 5)
2
>>> 'thư rác, thư rác, thư rác'.count('spam', 5, 10)
1
>>> 'thư rác, thư rác, thư rác'.count('trứng')
0
>>> 'thư rác, thư rác, thư rác'.count('')
17

str.encode(encoding='utf-8', errors='strict')

Trả về chuỗi được mã hóa thành bytes.

encoding mặc định là 'utf-8'; xem Mã hóa tiêu chuẩn để biết các giá trị có thể.

errors kiểm soát cách xử lý lỗi mã hóa. Nếu 'strict' (mặc định), ngoại lệ UnicodeError sẽ xuất hiện. Các giá trị có thể khác là 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' và bất kỳ tên nào khác được đăng ký qua codecs.register_error(). Xem Trình xử lý lỗi để biết chi tiết.

Vì lý do hiệu suất, giá trị của errors không được kiểm tra tính hợp lệ trừ khi thực sự xảy ra lỗi mã hóa, Chế độ phát triển Python được bật hoặc debug build được sử dụng. Ví dụ:

>>> mã hóa_str_to_bytes = 'Python'.encode()
>>> gõ(encoded_str_to_bytes)
<lớp 'byte'>
>>> được mã hóa_str_to_byte
b'Python'

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: Giá trị của đối số errors hiện được kiểm tra trong Chế độ phát triển Python và debug mode.

str.endswith(suffix[, start[, end]])

Trả về True nếu chuỗi kết thúc bằng suffix được chỉ định, nếu không thì trả về False. suffix cũng có thể là một bộ hậu tố cần tìm. Với start tùy chọn, bắt đầu kiểm tra ở vị trí đó. Với end tùy chọn, dừng so sánh ở vị trí đó. Sử dụng start và end tương đương với str[start:end].endswith(suffix). Ví dụ:

>>> 'Python'.endswith('on')
đúng
>>> 'một bộ hậu tố'.endswith(('at', 'in'))
sai
>>> 'một bộ hậu tố'.endswith(('at', 'es'))
đúng
>>> 'Python thật tuyệt vời'.endswith('is', 0, 9)
đúng

Xem thêm startswith() và removesuffix().

str.expandtabs(tabsize=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 khoảng trắng, tùy thuộc vào cột hiện tại và kích thước tab nhất định. Vị trí tab xuất hiện ở mọi ký tự tabsize (mặc định là 8, đưa ra 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 (\t), 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ị trí tab tiếp theo. (Bản thân ký tự tab không được sao chép.) Nếu ký tự đó là dòng mới (\n) hoặc trả về (\r), 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 được in. Ví dụ:

>>> '01\t012\t0123\t01234'.expandtabs()
'01 012 0123 01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01 012 0123 01234'
>>> print('01\t012\n0123\t01234'.expandtabs(4))
01 012
0123 01234

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

Trả về chỉ mục thấp nhất trong chuỗi nơi tìm thấy chuỗi con sub trong lát cắt s[start:end]. Các đối số tùy chọn start và end được hiểu là trong ký hiệu lát cắt. Trả về -1 nếu không tìm thấy sub. Ví dụ:

>>> 'thư rác, thư rác, thư rác'.find('sp')
0
>>> 'thư rác, thư rác, thư rác'.find('sp', 5)
6

Xem thêm rfind() và index().

Ghi chú

Phương pháp find() chỉ nên được sử dụng nếu bạn cần biết vị trí của sub. Để kiểm tra xem sub có phải là chuỗi con hay không, hãy sử dụng toán tử in

>>> 'Py' trong 'Python'
đúng

str.format(*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 cách bằng dấu ngoặc nhọn {}. 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ề 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. Ví dụ:

>>> "Tổng của 1 + 2 là {0}".format(1+2)
'Tổng của 1 + 2 là 3'
>>> "Tổng của {a} + {b} là {answer}".format(answer=1+2, a=1, b=2)
'Tổng của 1 + 2 là 3'
>>> "{1} mong đợi {0} Tòa án dị giáo!".format("Tiếng Tây Ban Nha", "Không ai")
'Không ai mong đợi Tòa án dị giáo Tây Ban Nha!'

Xem Cú pháp định dạng chuỗi để 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ố (int, float, complex, decimal.Decimal và các lớp con) với loại n (ví dụ: '{:n}'.format(1234)), hàm tạm thời đặt ngôn ngữ LC_CTYPE thành ngôn ngữ LC_NUMERIC để giải mã các trường decimal_point và thousands_sep của localeconv() nếu chúng không phải là ASCII hoặc dài hơn 1 byte và ngôn ngữ LC_NUMERIC khác với ngôn ngữ LC_CTYPE. 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ố có loại n, hàm này sẽ tạm thời đặt ngôn ngữ LC_CTYPE thành ngôn ngữ LC_NUMERIC trong một số trường hợp.

str.format_map(mapping, /)

Tương tự như str.format(**mapping), ngoại trừ mapping được sử dụng trực tiếp và không được sao chép sang dict. Điều này rất hữu ích nếu ví dụ mapping là một lớp con dict:

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

Added in version 3.2.

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

Giống như find(), nhưng tăng ValueError khi không tìm thấy chuỗi con. Ví dụ:

>>> 'thư rác, thư rác, thư rác'.index('spam')
0
>>> 'thư rác, thư rác, thư rác'.index('trứng')
Traceback (cuộc gọi gần đây nhất):
  Tệp "<python-input-0>", dòng 1, trong <module>
    'thư rác, thư rác, thư rác'.index('trứng')
    ~~~~~~~~~~~~~~~~~~~~~~~~~~ ^^ ^^ ^^ ^^
ValueError: không tìm thấy chuỗi con

Xem thêm rindex().

str.isalnum()

Trả về True 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ự, False nếu không. Ký tự c là chữ và số nếu một trong các ký tự sau trả về True: c.isalpha(), c.isdecimal(), c.isdigit() hoặc c.isnumeric(). Ví dụ:

>>> 'abc123'.isalnum()
đúng
>>> 'abc123!@#'.isalnum()
sai
>>> ''.isalnum()
sai
>>> ' '.isalnum()
sai

str.isalpha()

Trả về True 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ự, False nếu không. Ký tự chữ cái là những ký tự được xác định trong cơ sở dữ liệu ký tự Unicode là "Chữ cái", tức là những ký tự có thuộc tính danh mục chung là một trong các "Lm", "Lt", "Lu", "Ll" hoặc "Lo". Lưu ý rằng điều này khác với Alphabetic property defined in the section 4.10 'Letters, Alphabetic, and Ideographic' of the Unicode Standard. Ví dụ:

>>> 'Chữ cái và dấu cách'.isalpha()
sai
>>> 'LettersOnly'.isalpha()
đúng
>>> Các ký tự 'µ'.isalpha() # non-ASCII cũng có thể được coi là theo thứ tự bảng chữ cái
đúng

Xem Thuộc tính Unicode.

str.isascii()

Trả về True nếu chuỗi trống hoặc tất cả các ký tự trong chuỗi là ASCII, False nếu không. Các ký tự ASCII có điểm mã trong phạm vi U+0000-U+007F. Ví dụ:

>>> 'ký tự ASCII'.isascii()
đúng
>>> 'µ'.isascii()
sai

Added in version 3.7.

str.isdecimal()

Trả về True 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ự, False nếu không. Ký tự thập phân là những ký tự có thể được sử dụng để tạo thành số trong cơ số 10, chẳng hạn như U+0660, ARABIC-INDIC DIGIT ZERO. Về mặt hình thức, ký tự thập phân là ký tự trong Danh mục chung Unicode "Nd". Ví dụ:

>>> '0123456789'.isdecimal()
đúng
>>> '٠١٢٣٤٥٦٧٨٩'.isdecimal() # Arabic-Indic các chữ số từ 0 đến 9
đúng
>>> 'chữ cái'.isdecimal()
sai

str.isdigit()

Trả về True nếu tất cả các ký tự trong chuỗi là chữ số và có ít nhất một ký tự, False nếu không. Các chữ số bao gồm các ký tự thập phân và các chữ số cần xử lý đặc biệt, chẳng hạn như các 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. Về mặt hình thức, chữ số là ký tự có giá trị thuộc tính Numeric_Type=Digit hoặc Numeric_Type=Decimal.

str.isidentifier()

Trả về True nếu chuỗi là mã định danh hợp lệ theo định nghĩa ngôn ngữ, phần Tên (số nhận dạng và từ khóa).

keyword.iskeyword() có thể được sử dụng để kiểm tra xem chuỗi s có phải là mã định danh dành riêng hay không, chẳng hạn như def và class.

Ví dụ:

>>> từ nhập từ khóa iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
(Đúng, Sai)
>>> 'def'.isidentifier(), iskeyword('def')
(Đúng, Đúng)

str.islower()

Trả về True nếu tất cả các ký tự được viết hoa [4] trong chuỗi là chữ thường và có ít nhất một ký tự được viết hoa, nếu không thì là False.

str.isnumeric()

Trả về True 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ự, False nếu không. 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, ví dụ: U+2155, VULGAR FRACTION ONE FIFTH. Về mặt 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. Ví dụ:

>>> '0123456789'.isnumeric()
đúng
>>> '٠١٢٣٤٥٦٧٨٩'.isnumeric() # Arabic-indic chữ số từ 0 đến 9
đúng
>>> '⅕'.isnumeric() # Vulgar phân số một phần năm
đúng
>>> '2'.isdecimal(), '2'.isdigit(), '2'.isnumeric()
(Sai, Đúng, Đúng)

Xem thêm isdecimal() và isdigit(). Ký tự số là tập hợp lớn của số thập phân.

str.isprintable()

Trả về True nếu tất cả các ký tự trong chuỗi đều in được, False nếu nó chứa ít nhất một ký tự không in được.

Ở đây "có thể in được" có nghĩa là ký tự phù hợp để repr() sử dụng trong đầu ra của nó; "không thể in được" có nghĩa là repr() trên các loại tích hợp sẽ thoát khỏi ký tự hex. Nó không liên quan đến việc xử lý các chuỗi được ghi vào sys.stdout hoặc sys.stderr.

Các ký tự có thể in được là những ký tự trong cơ sở dữ liệu ký tự Unicode (xem unicodedata) có một danh mục chung trong nhóm Chữ cái, Dấu, Số, Dấu câu hoặc Ký hiệu (L, M, N, P hoặc S); cộng với không gian ASCII 0x20. Các ký tự không in được là các ký tự nằm trong nhóm Dấu tách hoặc Khác (Z hoặc C), ngoại trừ khoảng trắng ASCII.

Ví dụ:

>>> ''.isprintable(), ''.isprintable()
(Đúng, Đúng)
>>> '\t'.isprintable(), '\n'.isprintable()
(Sai, Sai)

Xem thêm isspace().

str.isspace()

Trả về True nếu chỉ có các ký tự khoảng trắng trong chuỗi và có ít nhất một ký tự, False nếu không.

Ví dụ:

>>> ''.isspace()
sai
>>> ' '.isspace()
đúng
>>> '\t\n'.isspace() # TAB và BREAK LINE
đúng
>>> '\u3000'.isspace() # IDEOGRAPHIC SPACE
đúng

Một ký tự là whitespace nếu trong cơ sở dữ liệu ký tự Unicode (xem unicodedata), danh mục chung của nó là Zs ("Dấu phân cách, dấu cách") hoặc lớp hai chiều của nó là một trong các WS, B hoặc S.

Xem thêm isprintable().

str.istitle()

Trả về True 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ự viết hoa chỉ có thể theo sau các ký tự không được viết hoa và các ký tự viết thường chỉ được viết hoa. Trả về False nếu không.

Ví dụ:

>>> 'Thư rác, thư rác, thư rác'.istitle()
đúng
>>> 'thư rác, thư rác, thư rác'.istitle()
sai
>>> 'SPAM, SPAM, SPAM'.istitle()
sai

Xem thêm title().

str.isupper()

Trả về True nếu tất cả các ký tự được viết hoa [4] trong chuỗi đều là chữ hoa và có ít nhất một ký tự được viết hoa, nếu không thì là False.

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable, /)

Trả về một chuỗi là chuỗi nối của các chuỗi trong iterable. Một TypeError sẽ được tă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ác đối tượng bytes. 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. Ví dụ:

>>> ', '.join(['spam', 'spam', 'spam'])
'thư rác, thư rác, thư rác'
>>> '-'.join('Python')
'P-y-t-h-o-n'

Xem thêm split().

str.ljust(width, fillchar=' ', /)

Trả về chuỗi căn trái trong chuỗi có độ dài width. Việc đệm được thực hiện bằng cách sử dụng fillchar được chỉ định (mặc định là khoảng trắng ASCII). Chuỗi gốc được trả về nếu width nhỏ hơn hoặc bằng len(s).

Ví dụ:

>>> 'Python'.ljust(10)
'Trăn'
>>> 'Python'.ljust(10, '.')
'Trăn....'
>>> 'Monty Python'.ljust(10, '.')
'Monty Python'

Xem thêm rjust().

str.lower()

Trả về một bản sao của chuỗi có tất cả các ký tự viết hoa [4] được chuyển đổi thành chữ thường. Ví dụ:

>>> 'Ví dụ về phương thức thấp hơn'.low()
'ví dụ về phương pháp thấp hơn'

Thuật toán viết thường được sử dụng là described in section 3.13 'Default Case Folding' of the Unicode Standard.

str.lstrip(chars=None, /)

Trả về bản sao của chuỗi đã loại bỏ các ký tự đầu. Đối số chars là một chuỗi chỉ định bộ ký tự cần xóa. Nếu bị bỏ qua hoặc None, đối số chars sẽ mặc định xóa khoảng trắng. Đối số chars không phải là tiền tố; đúng hơn, tất cả các kết hợp giá trị của nó đều bị loại bỏ

>>> ' rộng rãi '.lstrip()
'rộng rãi'
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

Xem str.removeprefix() để biết phương pháp loại bỏ một chuỗi tiền tố thay vì tất cả một bộ ký tự. Ví dụ:

>>> 'Arthur: ba!'.lstrip('Arthur: ')
'ê!'
>>> 'Arthur: ba!'.removeprefix('Arthur: ')
'ba!'

static str.maketrans(dict, /)

static str.maketrans(from, to, remove='', /)

Phương thức tĩnh này trả về một bảng dịch có thể sử dụng được cho str.translate().

Nếu chỉ có một đối số thì đó phải là một từ điển ánh xạ các thứ tự Unicode (số nguyên) hoặc ký tự (chuỗi có độ dài 1) sang thứ tự Unicode, chuỗi (có độ dài tùy ý) hoặc None. 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 from sẽ được ánh xạ tới ký tự ở cùng một vị trí trong to. 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 None trong kết quả.

str.partition(sep, /)

Tách chuỗi ở lần xuất hiện đầu tiên của sep và trả về một bộ 3 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 phân cách, hãy trả về bộ 3 chứa chính chuỗi đó, theo sau là hai chuỗi trống.

Ví dụ:

>>> 'Monty Python'.partition(' ')
('Monty', '', 'Python')
>>> "Rạp xiếc bay của Monty Python".partition(' ')
("Monty", '', "Rạp xiếc bay của Python")
>>> 'Monty Python'.partition('-')
("Monty Python", '', '')

Xem thêm rpartition().

str.removeprefix(prefix, /)

Nếu chuỗi bắt đầu bằng chuỗi prefix, trả về string[len(prefix):]. Ngược lại, trả về bản sao của chuỗi gốc:

>>> 'TestHook'.removeprefix('Test')
'Móc'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

Added in version 3.9.

Xem thêm removesuffix() và startswith().

str.removesuffix(suffix, /)

Nếu chuỗi kết thúc bằng chuỗi suffix và suffix đó không trống, hãy trả về string[:-len(suffix)]. Ngược lại, trả về bản sao của chuỗi gốc:

>>> 'MiscTests'.removesuffix('Tests')
'linh tinh'
>>> 'TmpDirMixin'.removesuffix('Thử nghiệm')
'TmpDirMixin'

Added in version 3.9.

Xem thêm removeprefix() và endswith().

str.replace(old, new, /, count=-1)

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 old được thay thế bằng new. Nếu count được cung cấp, chỉ những lần xuất hiện count đầu tiên mới được thay thế. Nếu count không được chỉ định hoặc -1 thì tất cả các lần xuất hiện sẽ được thay thế. Ví dụ:

>>> 'thư rác, thư rác, thư rác'.replace('thư rác', 'trứng')
'trứng, trứng, trứng'
>>> 'thư rác, thư rác, thư rác'.replace('thư rác', 'trứng', 1)
'trứng, thư rác, thư rác'

Thay đổi trong phiên bản 3.13: count hiện được hỗ trợ làm đối số từ khóa.

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

Trả về chỉ mục cao nhất trong chuỗi nơi tìm thấy chuỗi con sub, sao cho sub được chứa trong s[start:end]. Các đối số tùy chọn start và end được hiểu là trong ký hiệu lát cắt. Trả về -1 khi thất bại. Ví dụ:

>>> 'thư rác, thư rác, thư rác'.rfind('sp')
12
>>> 'thư rác, thư rác, thư rác'.rfind('sp', 0, 10)
6

Xem thêm find() và rindex().

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

Giống như rfind() nhưng tăng ValueError khi không tìm thấy chuỗi con sub. Ví dụ:

>>> 'thư rác, thư rác, thư rác'.rindex('spam')
12
>>> 'thư rác, thư rác, thư rác'.rindex('trứng')
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin-0>", dòng 1, trong <module>
    'thư rác, thư rác, thư rác'.rindex('trứng')
    ~~~~~~~~~~~~~~~~~~~~~~~~~~ ^^ ^^ ^^ ^^
ValueError: không tìm thấy chuỗi con

Xem thêm index() và find().

str.rjust(width, fillchar=' ', /)

Trả về chuỗi bên phải trong chuỗi có độ dài width. Việc đệm được thực hiện bằng cách sử dụng fillchar được chỉ định (mặc định là khoảng trắng ASCII). Chuỗi gốc được trả về nếu width nhỏ hơn hoặc bằng len(s).

Ví dụ:

>>> 'Python'.rjust(10)
'Trăn'
>>> 'Python'.rjust(10, '.')
'....Python'
>>> 'Monty Python'.rjust(10, '.')
'Monty Python'

Xem thêm ljust() và zfill().

str.rpartition(sep, /)

Tách chuỗi ở lần xuất hiện cuối cùng của sep và trả về một bộ 3 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 phân cách, hãy trả về bộ 3 chứa hai chuỗi trống, theo sau là chính chuỗi đó.

Ví dụ:

>>> 'Monty Python'.rpartition(' ')
('Monty', '', 'Python')
>>> "Rạp xiếc bay của Monty Python".rpartition(' ')
("Monty Python's Flying", '', 'Circus')
>>> 'Monty Python'.rpartition('-')
('', '', 'Monty Python')

Xem thêm partition().

str.rsplit(sep=None, maxsplit=-1)

Trả về danh sách các từ trong chuỗi, sử dụng sep làm chuỗi phân cách. Nếu maxsplit được đưa ra, thì nhiều nhất việc phân chia maxsplit đã được thực hiện, đó là việc phân chia rightmost. Nếu sep không được chỉ định hoặc None thì mọi chuỗi khoảng trắng đều là dấu phân cách. Ngoại trừ việc tách từ bên phải, rsplit() hoạt động giống như split() được mô tả chi tiết bên dưới.

str.rstrip(chars=None, /)

Trả về bản sao của chuỗi đã loại bỏ các ký tự ở cuối. Đối số chars là một chuỗi chỉ định bộ ký tự cần xóa. Nếu bị bỏ qua hoặc None, đối số chars sẽ mặc định xóa khoảng trắng. Đối số chars không phải là hậu tố; đúng hơn, tất cả các kết hợp giá trị của nó đều bị loại bỏ. Ví dụ:

>>> ' rộng rãi '.rstrip()
'rộng rãi'
>>> 'mississippi'.rstrip('ipz')
'quý cô'

Xem removesuffix() để biết phương pháp loại bỏ một chuỗi hậu tố thay vì tất cả một bộ ký tự. Ví dụ:

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

Xem thêm strip().

str.split(sep=None, maxsplit=-1)

Trả về danh sách các từ trong chuỗi, sử dụng sep làm chuỗi phân cách. Nếu maxsplit được đưa ra, thì việc phân chia tối đa maxsplit được thực hiện (do đó, danh sách sẽ có tối đa các phần tử maxsplit+1). Nếu maxsplit không được chỉ định hoặc -1 thì không có giới hạn về số lần phân chia (tất cả các lần phân chia 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 sẽ 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,,2'.split(',') trả về ['1', '', '2']). Đối số sep có thể bao gồm nhiều ký tự dưới dạng một dấu phân cách duy nhất (để phân tách bằng nhiều dấu phân cách, hãy sử dụng re.split()). Việc tách một chuỗi trống bằng dấu phân cách được chỉ định sẽ trả về [''].

Ví dụ:

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
>>> '1<>2<>3<4'.split('<>')
['1', '2', '3<4']

Nếu sep không được chỉ định hoặc là None, thì một thuật toán phân tách khác sẽ được áp dụng: các dòng khoảng trắng liên tiếp được coi là một dấu phân cách đơn 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ỉ gồm khoảng trắng bằng dấu phân cách None sẽ trả về [].

Ví dụ:

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> ' 1 2 3 '.split()
['1', '2', '3']

Nếu sep không được chỉ định hoặc là None và maxsplit là 0 thì chỉ các dòng đầu tiên của khoảng trắng liên tiếp mới được xem xét.

Ví dụ:

>>> "".split(Không, 0)
[]
>>> " ".split(Không có, 0)
[]
>>> " foo ".split(maxsplit=0)
['foo']

Xem thêm join().

str.splitlines(keepends=False)

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 đưa vào danh sách kết quả trừ khi keepends được đưa ra và đúng.

Phương pháp này phân chia trên các ranh giới dòng sau. Đặc biệt, các ranh giới là siêu tập hợp của universal newlines.

đại diện	Mô tả
\n	Nguồn cấp dữ liệu dòng
\r	Vận chuyển trở lại
\r\n	Vận chuyển trở lại + Nguồn cấp dữ liệu
\v hoặc \x0b	Lập bảng dòng
\f hoặc \x0c	Nguồn cấp dữ liệu biểu mẫu
\x1c	Dấu tách tập tin
\x1d	Dấu tách nhóm
\x1e	Dấu phân cách bản ghi
\x85	Dòng tiếp theo (Mã điều khiển C1)
\u2028	Dấu phân cách dòng
\u2029	Dấu phân cách đoạn

Thay đổi trong phiên bản 3.2: \v và \f được thêm vào danh sách ranh giới dòng.

Ví dụ:

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

Không giống như split() khi cung cấp một chuỗi phân cách sep, phương thức này trả về một danh sách trống cho chuỗi trống và việc ngắt dòng ở đầu cuối không dẫn đến một dòng bổ sung:

>>> "".splitlines()
[]
>>> "Một dòng\n".splitlines()
['Một dòng']

Để so sánh, split('\n') cho

>>> ''.split('\n')
['']
>>> 'Hai dòng\n'.split('\n')
['Hai dòng', '']

str.startswith(prefix[, start[, end]])

Trả về True nếu chuỗi bắt đầu bằng prefix, nếu không thì trả về False. prefix cũng có thể là một bộ tiền tố cần tìm. Với start tùy chọn, chuỗi kiểm tra bắt đầu tại vị trí đó. Với end tùy chọn, dừng so sánh chuỗi tại vị trí đó.

Ví dụ:

>>> 'Python'.startswith('Py')
đúng
>>> 'một bộ tiền tố'.startswith(('at', 'a'))
đúng
>>> 'Python thật tuyệt vời'.startswith('is', 7)
đúng

Xem thêm endswith() và removeprefix().

str.strip(chars=None, /)

Trả về bản sao của chuỗi đã loại bỏ các ký tự đầu và cuối. Đối số chars là một chuỗi chỉ định bộ ký tự cần xóa. Nếu bị bỏ qua hoặc None, đối số chars sẽ mặc định xóa khoảng trắng. Đối số chars không phải là tiền tố hoặc hậu tố; đúng hơn, tất cả các kết hợp giá trị của nó đều bị loại bỏ.

Ví dụ:

>>> ' rộng rãi '.strip()
'rộng rãi'
>>> 'www.example.com'.strip('cmowz.')
'ví dụ'

Các giá trị đối số chars ở đầ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 ký tự chuỗi không có trong bộ ký tự trong chars. Một hành động tương tự diễn ra ở đầu cuối.

Ví dụ:

>>> comment_string = '#....... Mục 3.2.1 Vấn đề #32 .......'
>>> comment_string.strip('.#! ')
'Mục 3.2.1 Vấn đề #32'

Xem thêm rstrip().

str.swapcase()

Trả về bản sao của chuỗi có ký tự in hoa được chuyển đổi thành chữ thường và ngược lại. Ví dụ:

>>> 'Xin chào thế giới'.swapcase()
'Xin chào thế giới'

Lưu ý rằng s.swapcase().swapcase() == s không nhất thiết đúng. Ví dụ:

>>> 'straße'.swapcase().swapcase()
'strasse'

Xem thêm str.lower() và str.upper().

str.title()

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

>>> 'Xin chào thế giới'.title()
'Xin chào thế giới'

Thuật toán sử dụng định nghĩa đơn giản, độc lập với 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 này có tác dụng trong nhiều ngữ cảnh nhưng nó có nghĩa là dấu nháy đơn trong cách viết tắt và sở hữu tạo thành ranh giới từ, điều này có thể không mang lại kết quả như mong muốn:

>>> "họ là bạn của Bill đến từ Anh".title()
"Họ là bạn của Bill đến từ Anh"

Hàm string.capwords() không gặp phải vấn đề này vì nó chỉ phân tách các từ trong khoảng trắng.

Ngoài ra, có thể xây dựng cách giải quyết cho dấu nháy đơn bằng cách sử dụng biểu thức chính quy

>>> nhập lại
>>> (các) chữ cái tiêu đề def:
... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
... lambda mo: mo.group(0).capitalize(),
... s)
...
>>> titlecase("họ là bạn của Bill.")
"Họ là bạn của Bill."

Xem thêm istitle().

str.translate(table, /)

Trả về một bản sao của chuỗi trong đó mỗi ký tự đã được ánh xạ thông qua bảng dịch đã cho. Bảng phải là một đối tượng thực hiện lập chỉ mục thông qua __getitem__(), thường là mapping hoặc sequence. Khi được lập chỉ mục theo thứ tự Unicode (số nguyên), đối tượng bảng có thể thực hiện bất kỳ thao tác nào sau đây: trả về thứ tự Unicode hoặc một chuỗi, để ánh xạ ký tự tới một hoặc nhiều ký tự khác; return None, để xóa ký tự khỏi chuỗi trả về; hoặc đưa ra một ngoại lệ LookupError để ánh xạ ký tự đó vào chính nó.

Bạn có thể sử dụng str.maketrans() để tạo bản đồ dịch từ ánh xạ ký tự này sang ký tự khác ở các định dạng khác nhau.

Xem thêm mô-đun codecs để có cách tiếp cận linh hoạt hơn với ánh xạ ký tự tùy chỉnh.

str.upper()

Trả về một bản sao của chuỗi có tất cả các ký tự viết hoa [4] được chuyển thành chữ hoa. Lưu ý rằng s.upper().isupper() có thể là False nếu s chứa các ký tự không được viết hoa hoặc nếu danh mục Unicode của (các) ký tự kết quả không phải là "Lu" (Chữ cái, chữ hoa), nhưng ví dụ: "Lt" (Thư, chữ hoa).

Thuật toán viết hoa được sử dụng là described in section 3.13 'Default Case Folding' of the Unicode Standard.

str.zfill(width, /)

Trả về một bản sao của chuỗi bên trái chứa đầy các chữ số ASCII '0' để tạo thành một chuỗi có độ dài width. Tiền tố dấu hiệu dẫn đầu ('+'/'-') được xử lý bằng cách chèn phần đệm after ký tự dấu hiệu thay vì trước đó. Chuỗi gốc được trả về nếu width nhỏ hơn hoặc bằng len(s).

Ví dụ:

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

Xem thêm rjust().

Chuỗi ký tự được định dạng (chuỗi f)

Added in version 3.6.

Thay đổi trong phiên bản 3.7: await và async for có thể được sử dụng trong các biểu thức trong chuỗi f.

Thay đổi trong phiên bản 3.8: Đã thêm trình xác định gỡ lỗi (=)

Thay đổi trong phiên bản 3.12: Nhiều hạn chế về biểu thức trong chuỗi f đã được loại bỏ. Đáng chú ý, các chuỗi lồng nhau, nhận xét và dấu gạch chéo ngược hiện đã được cho phép.

Một f-string (chính thức là formatted string literal) là một chuỗi ký tự có tiền tố là f hoặc F. Loại chuỗi ký tự này cho phép nhúng kết quả của các biểu thức Python tùy ý trong replacement fields, được phân cách bằng dấu ngoặc nhọn ({}). Mỗi trường thay thế phải chứa một biểu thức, tùy chọn theo sau là:

• a debug specifier -- dấu bằng (=);

• một conversion specifier -- !s, !r hoặc !a; và/hoặc

• một format specifier có tiền tố là dấu hai chấm (:).

Xem Lexical Analysis section on f-strings để biết chi tiết về cú pháp của các trường này.

Trình xác định lỗi

Added in version 3.8.

Nếu trình xác định gỡ lỗi -- dấu bằng (=) -- xuất hiện sau biểu thức trường thay thế, thì chuỗi f kết quả sẽ chứa nguồn của biểu thức, dấu bằng và giá trị của biểu thức. Điều này thường hữu ích cho việc gỡ lỗi:

>>> số = 14,3
>>> f'{số=}'
'số = 14,3'

Khoảng trắng trước, bên trong và sau biểu thức, cũng như khoảng trắng sau dấu bằng, rất quan trọng --- nó được giữ lại trong kết quả:

>>> f'{ số - 4 = }'
' số - 4 = 10,3'

Công cụ xác định chuyển đổi

Theo mặc định, giá trị của biểu thức trường thay thế được chuyển đổi thành chuỗi bằng str():

>>> từ phân số nhập Phân số
>>> one_third = Phân số(1, 3)
>>> f'{one_third}'
'1/3'

Khi một công cụ xác định gỡ lỗi nhưng không sử dụng công cụ xác định định dạng, thì chuyển đổi mặc định sẽ sử dụng repr():

>>> f'{one_third = }'
'một_thứ ba = Phân số(1, 3)'

Việc chuyển đổi có thể được chỉ định rõ ràng bằng cách sử dụng một trong các chỉ định sau:

• !s cho str()

• !r cho repr()

• !a cho ascii()

Ví dụ:

>>> str(one_third)
'1/3'
>>> đại diện (one_third)
'Phân số (1, 3)'

>>> f'{one_third!s} là {one_third!r}'
'1/3 là Phân số(1, 3)'

>>> chuỗi = "¡kočka 😸!"
>>> ascii(chuỗi)
"'\\xa1ko\\u010dka \\U0001f638!'"

>>> f'{string = !a}'
"string = '\\xa1ko\\u010dka \\U0001f638!'"

Công cụ xác định định dạng

Sau khi biểu thức đã được đánh giá và có thể được chuyển đổi bằng cách sử dụng một công cụ xác định chuyển đổi rõ ràng, biểu thức đó sẽ được định dạng bằng hàm format(). Nếu trường thay thế bao gồm format specifier được giới thiệu bởi dấu hai chấm (:), thì thông số xác định sẽ được chuyển tới format() làm đối số thứ hai. Kết quả của format() sau đó được sử dụng làm giá trị cuối cùng cho trường thay thế. Ví dụ:

>>> từ phân số nhập Phân số
>>> one_third = Phân số(1, 3)
>>> f'{one_third:.6f}'
'0.333333'
>>> f'{one_third:_^+10}'
'___+1/3___'
>>> >>> f'{one_third!r:_^20}'
'___Phân số(1, 3)___'
>>> f'{one_third = :~>10}~'
'một phần ba = ~~~~~~~1/3~'

Chuỗi ký tự mẫu (chuỗi t)

Một t-string (chính thức là template string literal) là một chuỗi ký tự có tiền tố là t hoặc T.

Các chuỗi này tuân theo cú pháp và quy tắc đánh giá giống như formatted string literals, với những điểm khác biệt sau:

• Thay vì đánh giá một đối tượng str, các chuỗi ký tự mẫu sẽ đánh giá một đối tượng string.templatelib.Template.

• Giao thức format() không được sử dụng. Thay vào đó, trình xác định định dạng và chuyển đổi (nếu có) được chuyển đến đối tượng Interpolation mới được tạo cho mỗi biểu thức được đánh giá. Tùy thuộc vào mã xử lý đối tượng Template thu được để quyết định cách xử lý các chuyển đổi và chỉ định định dạng.

• Bộ xác định định dạng chứa các trường thay thế lồng nhau được đánh giá một cách háo hức trước khi được chuyển đến đối tượng Interpolation. Ví dụ: phép nội suy có dạng {amount:.{precision}f} sẽ đánh giá biểu thức bên trong {precision} để xác định giá trị của thuộc tính format_spec. Nếu precision là 2 thì bộ định dạng kết quả sẽ là '.2f'.

• Khi dấu bằng '=' được cung cấp trong biểu thức nội suy, văn bản của biểu thức sẽ được thêm vào chuỗi ký tự đứng trước phép nội suy có liên quan. Điều này bao gồm dấu bằng và mọi khoảng trắng xung quanh. Phiên bản Interpolation cho biểu thức sẽ được tạo như bình thường, ngoại trừ conversion sẽ được đặt thành 'r' (repr()) theo mặc định. Nếu một công cụ xác định định dạng hoặc chuyển đổi rõ ràng được cung cấp, điều này sẽ ghi đè hành vi mặc định.

Định dạng chuỗi kiểu printf

Ghi chú

Các thao tác định dạng được mô tả ở đây có nhiều điểm khác biệt 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 formatted string literals, giao diện str.format() hoặc string.Template có thể giúp tránh những lỗi này. Mỗi lựa chọn thay thế này đều mang lại sự đánh đổi và lợi ích riê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ử % (modulo). Đây còn được gọi là toán tử chuỗi formatting hoặc interpolation. Cho format % values (trong đó format là một chuỗi), các thông số chuyển đổi % trong format được thay thế bằng 0 hoặc nhiều phần tử của values. Hiệu ứng này tương tự như việc sử dụng hàm sprintf() trong ngôn ngữ C. Ví dụ:

>>> print('%s có %d loại trích dẫn.' % ('Python', 2))
Python có 2 loại trích dẫn.

Nếu format yêu cầu một đối số duy nhất, values có thể là một đối tượng không phải là một bộ. [5] Mặt khác, values phải là một bộ dữ liệu có chính xác số lượng mục được chỉ định bởi chuỗi định dạng hoặc một đối tượng ánh xạ duy nhất (ví dụ: từ điển).

Công cụ xác định chuyển đổi chứa hai ký tự trở lên và có các thành phần sau, phải xuất hiện theo thứ tự sau:

1. Ký tự '%', đánh dấu sự bắt đầu của bộ xác định.

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

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à '*' (dấu hoa thị), chiều rộng thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu trong values và đối tượng cần chuyển đổi sẽ xuất hiện sau độ 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 cung cấp dưới dạng '.' (dấu chấm), theo sau là độ chính xác. Nếu được chỉ định là '*' (dấu hoa thị), độ chính xác thực tế sẽ được đọc từ phần tử tiếp theo của bộ dữ liệu trong values và giá trị cần chuyển đổi sẽ 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 must sẽ bao gồm khóa ánh xạ được đặt trong ngoặc đơn vào từ điển đó được chèn ngay sau ký tự '%'. Khóa ánh xạ chọn giá trị cần định dạng từ ánh xạ. Ví dụ:

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

Trong trường hợp này, không có thông số xác định * nào có thể xuất hiện ở một đị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à:

Cờ	Ý nghĩa
'#'	Việc chuyển đổi giá trị sẽ sử dụng "dạng thay thế" (được xác định bên dưới).
'0'	Việc chuyển đổi sẽ được đệm bằng 0 đối với các giá trị số.
'-'	Giá trị chuyển đổi được điều chỉnh trái (ghi đè chuyển đổi '0' nếu cả hai đều được cung cấp).
' '	(dấu cách) Phải để trống trước số dương (hoặc chuỗi trống) do chuyển đổi có dấu tạo ra.
'+'	Ký tự dấu ('+' hoặc '-') sẽ đứng trước quá trình chuyển đổi (ghi đè cờ "dấu cách").

Công cụ sửa đổi độ dài (h, l hoặc L) có thể xuất hiện nhưng bị bỏ qua vì nó không cần thiết đối với Python -- ví dụ: %ld giống hệt %d.

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

Chuyển đổi	Ý nghĩa	Ghi chú
'd'	Số thập phân có dấu số nguyên.
'i'	Số thập phân có dấu số nguyên.
'o'	Giá trị bát phân có dấu.	(1)
'u'	Loại lỗi thời -- nó giống hệt với 'd'.	(6)
'x'	Hệ thập lục phân có dấu (chữ thường).	(2)
'X'	Ký hiệu thập lục phân (chữ hoa).	(2)
'e'	Định dạng số mũ dấu phẩy động (chữ thường).	(3)
'E'	Định dạng số mũ dấu phẩy động (chữ hoa).	(3)
'f'	Định dạng thập phân dấu phẩy động.	(3)
'F'	Định dạng thập phân dấu phẩy động.	(3)
'g'	Định dạng dấu phẩy động. Sử dụng định dạng hàm 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ì sử dụng định dạng thập phân.	(4)
'G'	Định dạng dấu phẩy động. Sử dụng định dạng hàm 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ì sử dụng định dạng thập phân.	(4)
'c'	Ký tự đơn (chấp nhận số nguyên hoặc chuỗi ký tự đơn).
'r'	Chuỗi (chuyển đổi bất kỳ đối tượng Python nào bằng repr()).	(5)
's'	Chuỗi (chuyển đổi bất kỳ đối tượng Python nào bằng str()).	(5)
'a'	Chuỗi (chuyển đổi bất kỳ đối tượng Python nào bằng ascii()).	(5)
'%'	Không có đối số nào được chuyển đổi, dẫn đến ký tự '%' trong kết quả.

Đối với các định dạng dấu phẩy động, kết quả phải được làm tròn chính xác đến độ chính xác nhất định p của các chữ số sau dấu thập phân. Chế độ làm tròn phù hợp với chế độ tích hợp round().

Ghi chú:

1. Dạng thay thế làm cho bộ xác định bát phân hàng đầu ('0o') được chèn trước chữ số đầu tiên.

2. Dạng thay thế khiến một '0x' hoặc '0X' đứng đầu (tùy thuộc vào việc định dạng 'x' hay 'X' được sử dụng) được chèn 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.

   Độ 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ư bình thường.

   Độ 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à N, đầu ra sẽ bị cắt ngắn thành các ký tự N.

6. Xem PEP 237.

Vì chuỗi Python có độ dài rõ ràng nên chuyển đổi %s không cho rằng '\0' là phần cuối của chuỗi.

Thay đổi trong phiên bản 3.1: Chuyển đổi %f 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 %g nữa.

Các loại chuỗi nhị phân --- bytes, bytearray, memoryview

Các loại tích hợp cốt lõi để thao tác dữ liệu nhị phân là bytes và bytearray. Chúng được hỗ trợ bởi memoryview sử dụng buffer protocol để 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 array 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à các giá trị nổi có độ chính xác kép IEEE754.

Đối tượng byte

Đối tượng byte là 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, nên 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 với 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.

class bytes(source=b'')

class bytes(source, encoding, errors='strict')

Thứ nhất, cú pháp cho chuỗi ký tự byte phần lớn giống với cú pháp cho chuỗi ký tự, ngoại trừ tiền tố b được thêm vào:

• Dấu ngoặc đơn: b'still allows embedded "double" quotes'

• Dấu ngoặc kép: b"still allows embedded 'single' quotes"

• Trích dẫn ba lần: b'''3 single quotes''', b"""3 double quotes"""

Chỉ cho phép các ký tự ASCII ở dạng chữ byte (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 dạng chữ byte bằng cách sử dụng chuỗi thoát thích hợp.

Giống như các chuỗi ký tự, các ký tự byte cũng có thể sử dụng tiền tố r để vô hiệu hóa việc xử lý các chuỗi thoát. Xem Chuỗi và byte bằng chữ để biết thêm về các dạng chữ byte khác nhau, bao gồm cả các chuỗi thoát được hỗ trợ.

Mặc dù các ký tự và cách biểu diễn byte 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ị giới hạn sao cho 0 <= x < 256 (cố gắng vi phạm hạn chế này sẽ kích hoạt ValueError). Điều này được thực hiện có chủ ý để nhấn mạnh rằng mặc dù nhiều định dạng nhị phân bao gồm các phần tử dựa trên ASCII và có thể được thao tác một cách hữu ích bằng một số thuật toán hướng văn bản, nhưng đ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 tương thích với ASCII thường sẽ dẫn đến hỏng dữ liệu).

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:

• Đối tượng byte chứa đầy 0 có độ dài được chỉ định: bytes(10)

• Từ một số nguyên có thể lặp lại: bytes(range(20))

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

Đồng thời xem phần tích hợp bytes.

Vì 2 chữ số thập lục phân tương ứng chính xác với một byte đơn nê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 byte có thêm một phương thức lớp để đọc dữ liệu ở định dạng đó:

classmethod fromhex(string, /)

Phương thức lớp bytes 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, với khoảng trắng ASCII bị bỏ qua.

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

Thay đổi trong phiên bản 3.7: bytes.fromhex() hiện bỏ qua tất cả khoảng trắng ASCII trong chuỗi, không chỉ khoảng trắng.

Thay đổi trong phiên bản 3.14: bytes.fromhex() hiện chấp nhận ASCII bytes và bytes-like objects làm đầu vào.

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(*, bytes_per_sep=1)

hex(sep, bytes_per_sep=1)

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 phiên bản.

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

Nếu muốn làm cho chuỗi hex dễ đọc hơn, bạn có thể chỉ định tham số sep phân tách ký tự đơn để đưa vào đầu ra. Theo mặc định, dấu phân cách này sẽ nằ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. Giá trị dương tính toán vị trí dấu phân cách từ bên phải, giá trị âm tính từ bên trái.

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

Added in version 3.5.

Thay đổi trong phiên bản 3.8: bytes.hex() 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 byte là chuỗi các số nguyên (gần giống với một bộ dữ liệu), nên đối tượng byte b, b[0] sẽ là số nguyên, trong khi b[0:1] sẽ là đối tượng byte có độ dài 1. (Điều này trái ngược với chuỗi văn bản, trong đó cả việc lập chỉ mục và cắt lá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ữ (b'...') vì nó thường hữu ích hơn ví dụ: bytes([46, 46, 46]). Bạn luôn có thể chuyển đổi một đối tượng byte thành danh sách các số nguyên bằng list(b).

Đối tượng bytearray

Đối tượng bytearray là đối tượng có thể thay đổi đối với đối tượng bytes.

class bytearray(source=b'')

class bytearray(source, encoding, errors='strict')

Không có cú pháp cụ thể 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: bytearray()

• Tạo một phiên bản chứa đầy số 0 với độ dài nhất định: bytearray(10)

• Từ một số nguyên có thể lặp lại: bytearray(range(20))

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

Vì các đối tượng bytearray có thể thay đổi được nên chúng hỗ trợ các hoạt động chuỗi mutable bên cạnh các hoạt động byte và bytearray phổ biến được mô tả trong Hoạt động byte và bytearray.

Đồng thời xem phần tích hợp bytearray.

Vì 2 chữ số thập lục phân tương ứng chính xác với một byte đơn nê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 đó:

classmethod fromhex(string, /)

Phương thức lớp bytearray 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, với khoảng trắng ASCII bị bỏ qua.

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

Thay đổi trong phiên bản 3.7: bytearray.fromhex() hiện bỏ qua tất cả khoảng trắng ASCII trong chuỗi, không chỉ khoảng trắng.

Thay đổi trong phiên bản 3.14: bytearray.fromhex() hiện chấp nhận ASCII bytes và bytes-like objects làm đầu vào.

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(*, bytes_per_sep=1)

hex(sep, bytes_per_sep=1)

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 phiên bản.

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

Added in version 3.5.

Thay đổi trong phiên bản 3.8: Tương tự như bytes.hex(), bytearray.hex() 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.

resize(size, /)

Thay đổi kích thước bytearray để chứa byte size. size phải lớn hơn hoặc bằng 0.

Nếu bytearray cần thu nhỏ lại, các byte vượt quá size sẽ bị cắt bớt.

Nếu bytearray cần phát triển, tất cả các byte mới, những byte ngoài size, sẽ được đặt thành byte rỗng.

Điều này tương đương với:

>>> def resize(ba, size):
...     if len(ba) > size:
...         del ba[size:]
...     else:
...         ba += b'\0' * (size - len(ba))

Ví dụ:

>>> shrink = bytearray(b'abc')
>>> shrink.resize(1)
>>> (shrink, len(shrink))
(bytearray(b'a'), 1)
>>> grow = bytearray(b'abc')
>>> grow.resize(5)
>>> (grow, len(grow))
(bytearray(b'abc\x00\x00'), 5)

Added in version 3.14.

Vì các đối tượng bytearray là các chuỗi số nguyên (gần giống với một danh sách), nên đối với đối tượng bytearray b, b[0] sẽ là một số nguyên, trong khi b[0:1] sẽ là một đối tượng bytearray có độ dài 1. (Điều này trái ngược với các chuỗi văn bản, trong đó cả việc lập chỉ mục và cắt lá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 chữ byte (bytearray(b'...')) vì nó thường hữu ích hơn ví dụ: bytearray([46, 46, 46]). Bạn luôn có thể chuyển đổi một đối tượng bytearray thành danh sách các số nguyên bằng list(b).

Xem thêm

Để biết thông tin chi tiết về đảm bảo an toàn luồng cho các đối tượng bytearray, hãy xem An toàn luồng cho các đối tượng bytearray.

Hoạt động byte và bytearray

Cả hai đối tượng byte và bytearray đều hỗ trợ các hoạt động chuỗi common. 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ỳ bytes-like object nào. Nhờ tính linh hoạt này, chúng có thể được tự do trộn lẫn trong các hoạt động mà không gây ra sai sót. Tuy nhiên, kiểu trả về của kết quả có thể phụ thuộc vào thứ tự của toán hạng.

Ghi chú

Các phương thức trên byte và đối tượng bytearray không chấp nhận chuỗi làm đối số của chúng, cũng như các phương thức trên chuỗi không chấp nhận byte làm đối số của chúng. Ví dụ: bạn phải viết:

a = "abc"
b = a.replace("a", "f")

và:

a = b"abc"
b = a.replace(b"a", b"f")

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ú

Việc sử dụng các thao tác 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ác phương pháp sau đây trên các đối tượng byte và bytearray có thể được sử dụng với dữ liệu nhị phân tùy ý.

bytes.count(sub[, start[, end]])

bytearray.count(sub[, start[, end]])

Trả về số lần xuất hiện không chồng lấp của dãy con sub trong phạm vi [start, end]. Các đối số tùy chọn start và end được hiểu là trong ký hiệu lát cắt.

Dãy con cần tìm có thể là bất kỳ bytes-like object nào hoặc một số nguyên trong khoảng từ 0 đến 255.

Nếu sub 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: Đồng thời chấp nhận một số nguyên trong phạm vi từ 0 đến 255 làm dãy con.

bytes.removeprefix(prefix, /)

bytearray.removeprefix(prefix, /)

Nếu dữ liệu nhị phân bắt đầu bằng chuỗi prefix, hãy trả về bytes[len(prefix):]. Nếu không, hãy trả về bản sao của dữ liệu nhị phân gốc:

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

Zz001zz có thể là bất kỳ bytes-like object nào.

Ghi chú

Phiên bản bytearray của phương thức này not 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.

Added in version 3.9.

bytes.removesuffix(suffix, /)

bytearray.removesuffix(suffix, /)

Nếu dữ liệu nhị phân kết thúc bằng chuỗi suffix và suffix đó không trống, hãy trả về bytes[:-len(suffix)]. Nếu không, hãy trả về bản sao của dữ liệu nhị phân gốc:

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

Zz001zz có thể là bất kỳ bytes-like object nào.

Ghi chú

Phiên bản bytearray của phương thức này not 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.

Added in version 3.9.

bytes.decode(encoding='utf-8', errors='strict')

bytearray.decode(encoding='utf-8', errors='strict')

Trả lại các byte được giải mã thành str.

encoding mặc định là 'utf-8'; xem Mã hóa tiêu chuẩn để biết các giá trị có thể.

errors kiểm soát cách xử lý lỗi giải mã. Nếu 'strict' (mặc định), ngoại lệ UnicodeError sẽ xuất hiện. Các giá trị có thể khác là 'ignore', 'replace' và bất kỳ tên nào khác được đăng ký qua codecs.register_error(). Xem Trình xử lý lỗi để biết chi tiết.

Vì lý do hiệu suất, giá trị của errors không được kiểm tra tính hợp lệ trừ khi thực sự xảy ra lỗi giải mã, Chế độ phát triển Python được bật hoặc debug build được sử dụng.

Ghi chú

Việc chuyển đối số encoding sang str cho phép giải mã trực tiếp bất kỳ bytes-like object nào mà không cần tạo đối tượng bytes hoặc bytearray tạm thờ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: Giá trị của đối số errors hiện được kiểm tra trong Chế độ phát triển Python và debug mode.

bytes.endswith(suffix[, start[, end]])

bytearray.endswith(suffix[, start[, end]])

Trả về True nếu dữ liệu nhị phân kết thúc bằng suffix được chỉ định, nếu không thì trả về False. suffix cũng có thể là một bộ hậu tố cần tìm. Với start tùy chọn, bắt đầu kiểm tra ở vị trí đó. Với end tùy chọn, dừng so sánh ở vị trí đó.

(Các) hậu tố cần tìm kiếm có thể là bất kỳ bytes-like object nào.

bytes.find(sub[, start[, end]])

bytearray.find(sub[, start[, end]])

Trả về chỉ mục thấp nhất trong dữ liệu nơi tìm thấy dãy con sub, sao cho sub được chứa trong lát cắt s[start:end]. Các đối số tùy chọn start và end được hiểu là trong ký hiệu lát cắt. Trả về -1 nếu không tìm thấy sub.

Dãy con cần tìm có thể là bất kỳ bytes-like object nào hoặc một số nguyên trong khoảng từ 0 đến 255.

Ghi chú

Phương pháp find() chỉ nên được sử dụng nếu bạn cần biết vị trí của sub. Để kiểm tra xem sub có phải là chuỗi con hay không, hãy sử dụng toán tử in

>>> b'Py' trong b'Python'
đúng

Thay đổi trong phiên bản 3.3: Đồng thời chấp nhận một số nguyên trong phạm vi từ 0 đến 255 làm dãy con.

bytes.index(sub[, start[, end]])

bytearray.index(sub[, start[, end]])

Giống như find(), nhưng tăng ValueError khi không tìm thấy chuỗi con.

Dãy con cần tìm có thể là bất kỳ bytes-like object nào hoặc một số nguyên trong khoảng từ 0 đến 255.

Thay đổi trong phiên bản 3.3: Đồng thời chấp nhận một số nguyên trong phạm vi từ 0 đến 255 làm dãy con.

bytes.join(iterable, /)

bytearray.join(iterable, /)

Trả về một đối tượng byte hoặc bytearray là sự kết hợp của các chuỗi dữ liệu nhị phân trong iterable. Một TypeError sẽ được tăng lên nếu có bất kỳ giá trị nào trong iterable không phải là bytes-like objects, bao gồm cả các đối tượng str. 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.

static bytes.maketrans(from, to, /)

static bytearray.maketrans(from, to, /)

Phương thức tĩnh này trả về một bảng dịch có thể sử dụng được cho bytes.translate(). Bảng này sẽ ánh xạ từng ký tự trong from vào ký tự ở cùng vị trí trong to; from và to đều phải là bytes-like objects và có cùng độ dài.

Added in version 3.1.

bytes.partition(sep, /)

bytearray.partition(sep, /)

Tách chuỗi ở lần xuất hiện đầu tiên của sep và trả về bộ 3 chứa phần trước dấu phân cách, chính dấu phân cách hoặc bản sao bytearray của nó và phần sau dấu phân cách. Nếu không tìm thấy dấu phân cách, hãy trả về bộ 3 chứa bản sao của chuỗi ban đầu, theo sau là hai byte trống hoặc đối tượng bytearray.

Dấu phân cách cần tìm có thể là bất kỳ bytes-like object nào.

bytes.replace(old, new, count=-1, /)

bytearray.replace(old, new, count=-1, /)

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

Dãy con cần tìm và thay thế nó có thể là bất kỳ bytes-like object nào.

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.rfind(sub[, start[, end]])

bytearray.rfind(sub[, start[, end]])

Trả về chỉ số cao nhất trong chuỗi nơi tìm thấy chuỗi con sub, sao cho sub được chứa trong s[start:end]. Các đối số tùy chọn start và end được hiểu là trong ký hiệu lát cắt. Trả về -1 khi thất bại.

Dãy con cần tìm có thể là bất kỳ bytes-like object nào hoặc một số nguyên trong khoảng từ 0 đến 255.

Thay đổi trong phiên bản 3.3: Đồng thời chấp nhận một số nguyên trong phạm vi từ 0 đến 255 làm dãy con.

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

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

Giống như rfind() nhưng tăng ValueError khi không tìm thấy dãy sub.

Dãy con cần tìm có thể là bất kỳ bytes-like object nào hoặc một số nguyên trong khoảng từ 0 đến 255.

Thay đổi trong phiên bản 3.3: Đồng thời chấp nhận một số nguyên trong phạm vi từ 0 đến 255 làm dãy con.

bytes.rpartition(sep, /)

bytearray.rpartition(sep, /)

Tách chuỗi ở lần xuất hiện cuối cùng của sep và trả về bộ 3 chứa phần trước dấu phân cách, chính dấu phân cách hoặc bản sao bytearray của nó và phần sau dấu phân cách. Nếu không tìm thấy dấu phân cách, hãy trả về bộ 3 chứa hai byte trống hoặc đối tượng bytearray, theo sau là bản sao của chuỗi ban đầu.

Dấu phân cách cần tìm có thể là bất kỳ bytes-like object nào.

bytes.startswith(prefix[, start[, end]])

bytearray.startswith(prefix[, start[, end]])

Trả về True nếu dữ liệu nhị phân bắt đầu bằng prefix được chỉ định, nếu không thì trả về False. prefix cũng có thể là một bộ tiền tố cần tìm. Với start tùy chọn, bắt đầu kiểm tra ở vị trí đó. Với end tùy chọn, dừng so sánh ở vị trí đó.

(Các) tiền tố cần tìm kiếm có thể là bất kỳ bytes-like object nào.

bytes.translate(table, /, delete=b'')

bytearray.translate(table, /, delete=b'')

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

Bạn có thể sử dụng phương pháp bytes.maketrans() để tạo bảng dịch.

Đặt đối số table thành None cho các bản dịch chỉ xóa các ký tự:

>>> b'đọc đoạn văn ngắn này'.translate(Không, b'aeiou')
b'rd ths shrt txt'

Thay đổi trong phiên bản 3.6: delete hiện được hỗ trợ làm đối số từ khóa.

Các phương thức sau đây trên các đối tượng byte và bytearray có hành vi mặc định giả sử sử dụng đị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 đều thực hiện not hoạt động tại chỗ và thay vào đó tạo ra các đối tượng mới.

bytes.center(width, fillbyte=b' ', /)

bytearray.center(width, fillbyte=b' ', /)

Trả về một bản sao của đối tượng được căn giữa theo một chuỗi có độ dài width. Việc đệm được thực hiện bằng cách sử dụng fillbyte được chỉ định (mặc định là khoảng trắng ASCII). Đối với các đối tượng bytes, chuỗi ban đầu được trả về nếu width nhỏ hơn hoặc bằng len(s).

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.ljust(width, fillbyte=b' ', /)

bytearray.ljust(width, fillbyte=b' ', /)

Trả về một bản sao của đối tượng được căn đều bên trái theo trình tự có độ dài width. Việc đệm được thực hiện bằng cách sử dụng fillbyte được chỉ định (mặc định là khoảng trắng ASCII). Đối với các đối tượng bytes, chuỗi ban đầu được trả về nếu width nhỏ hơn hoặc bằng len(s).

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.lstrip(bytes=None, /)

bytearray.lstrip(bytes=None, /)

Trả về một bản sao của chuỗi đã loại bỏ các byte đầu tiên được chỉ định. Đối số bytes là một chuỗi nhị phân chỉ định tập hợp các giá trị byte cần xóa. Nếu bị bỏ qua hoặc None, đối số bytes sẽ xóa khoảng trắng ASCII theo mặc định. Đối số bytes không phải là tiền tố; đúng hơn, tất cả các kết hợp giá trị của nó đều bị loại bỏ

>>> b' rộng rãi '.lstrip()
b rộng rãi '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

Chuỗi nhị phân của các giá trị byte cần loại bỏ có thể là bất kỳ bytes-like object nào. Xem removeprefix() để biết phương pháp loại bỏ một chuỗi tiền tố thay vì tất cả một bộ ký tự. Ví dụ:

>>> b'Arthur: ba!'.lstrip(b'Arthur: ')
chào bạn!'
>>> b'Arthur: ba!'.removeprefix(b'Arthur: ')
b'ba!'

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.rjust(width, fillbyte=b' ', /)

bytearray.rjust(width, fillbyte=b' ', /)

Trả về một bản sao của đối tượng được căn phải theo trình tự có độ dài width. Việc đệm được thực hiện bằng cách sử dụng fillbyte được chỉ định (mặc định là khoảng trắng ASCII). Đối với các đối tượng bytes, chuỗi ban đầu được trả về nếu width nhỏ hơn hoặc bằng len(s).

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.rsplit(sep=None, maxsplit=-1)

bytearray.rsplit(sep=None, maxsplit=-1)

Chia 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ì nhiều nhất việc phân chia maxsplit đã được thực hiện, đó là việc phân chia rightmost. Nếu sep hoặc None không được chỉ định, thì bất kỳ chuỗi con nào chỉ bao gồm khoảng trắng ASCII đều là dấu phân cách. Ngoại trừ việc tách từ bên phải, rsplit() hoạt động giống như split() được mô tả chi tiết bên dưới.

bytes.rstrip(bytes=None, /)

bytearray.rstrip(bytes=None, /)

Trả về một bản sao của chuỗi đã loại bỏ các byte ở cuối được chỉ định. Đối số bytes là một chuỗi nhị phân chỉ định tập hợp các giá trị byte cần xóa. Nếu bị bỏ qua hoặc None, đối số bytes sẽ xóa khoảng trắng ASCII theo mặc định. Đối số bytes không phải là hậu tố; đúng hơn, tất cả các kết hợp giá trị của nó đều bị loại bỏ

>>> b' rộng rãi '.rstrip()
b' rộng rãi'
>>> b'mississippi'.rstrip(b'ipz')
b'missis'

Chuỗi nhị phân của các giá trị byte cần loại bỏ có thể là bất kỳ bytes-like object nào. Xem removesuffix() để biết phương pháp loại bỏ một chuỗi hậu tố thay vì tất cả một bộ ký tự. Ví dụ:

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.split(sep=None, maxsplit=-1)

bytearray.split(sep=None, maxsplit=-1)

Chia 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 cho trước và không âm, thì nhiều nhất việc phân chia maxsplit được thực hiện (do đó, danh sách sẽ có nhiều nhất là các phần tử maxsplit+1). Nếu maxsplit không được chỉ định hoặc là -1 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 chia 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 sẽ không được nhóm lại với nhau và được coi là phân cách các chuỗi con trống (ví dụ: b'1,,2'.split(b',') trả về [b'1', b'', b'2']). Đối số sep có thể bao gồm một chuỗi nhiều byte dưới dạng một dấu phân cách duy nhất. Việc tách một chuỗi trống bằng dấu phân cách được chỉ định sẽ trả về [b''] hoặc [bytearray(b'')] tùy thuộc vào loại đối tượng được phân tách. Đối số sep có thể là bất kỳ bytes-like object nào.

Ví dụ:

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']
>>> b'1<>2<>3<4'.split(b'<>')
[b'1', b'2', b'3<4']

Nếu sep không được chỉ định hoặc là None, thì một thuật toán phân tách khác sẽ được áp dụng: các chuỗi khoảng trắng ASCII liên tiếp được coi là một dấu phân cách đơn và kết quả sẽ không chứa chuỗi trống ở đầu hoặc cuối nếu chuỗi có khoảng trắng ở đầu hoặc cuối. Do đó, việc tách một chuỗi trống hoặc một chuỗi chỉ bao gồm khoảng trắng ASCII mà không có dấu phân cách được chỉ định sẽ trả về [].

Ví dụ:

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b' 1 2 3 '.split()
[b'1', b'2', b'3']

bytes.strip(bytes=None, /)

bytearray.strip(bytes=None, /)

Trả về một bản sao của chuỗi đã loại bỏ các byte đầu và cuối được chỉ định. Đối số bytes là một chuỗi nhị phân chỉ định tập hợp các giá trị byte cần xóa. Nếu bị bỏ qua hoặc None, đối số bytes sẽ xóa khoảng trắng ASCII theo mặc định. Đối số bytes không phải là tiền tố hoặc hậu tố; đúng hơn, tất cả các kết hợp giá trị của nó đều bị loại bỏ

>>> b' rộng rãi '.strip()
b rộng rãi'
>>> b'www.example.com'.strip(b'cmowz.')
b'ví dụ'

Chuỗi nhị phân của các giá trị byte cần loại bỏ có thể là bất kỳ bytes-like object nào.

Ghi chú

Phiên bản bytearray của phương thức này not 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 đây trên các đối tượng byte và bytearray giả sử sử dụng định dạng nhị phân tương thích ASCII và không nên á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 đều thực hiện not hoạt động tại chỗ và thay vào đó tạo ra các đối tượng mới.

bytes.capitalize()

bytearray.capitalize()

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 truyền qua không thay đổi.

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

Trả về 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 nhất định. Vị trí tab xuất hiện mỗi byte tabsize (mặc định là 8, cung cấp vị trí tab ở các cột 0, 8, 16, v.v.). Để mở rộng trình tự, cột hiện tại được đặt thành 0 và trình tự được kiểm tra từng byte. Nếu byte là ký tự tab ASCII (b'\t'), 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ị 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à dòng mới ASCII (b'\n') hoặc trả về đầu dòng (b'\r'), thì 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 đều đượ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 được in:

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01 012 0123 01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01 012 0123 01234'

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.isalnum()

bytearray.isalnum()

Trả về True nếu tất cả byte trong chuỗi là các ký tự ASCII theo thứ tự bảng chữ cái hoặc ASCII chữ số thập phân và chuỗi không trống, ngược lại là False. Các ký tự chữ cái ASCII là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'. Các chữ số thập phân ASCII là các giá trị byte trong chuỗi b'0123456789'.

Ví dụ:

>>> b'ABCabc1'.isalnum()
đúng
>>> b'ABC abc1'.isalnum()
sai

bytes.isalpha()

bytearray.isalpha()

Trả về True nếu tất cả byte trong chuỗi là các ký tự chữ cái ASCII và chuỗi không trống, ngược lại là False. Các ký tự chữ cái ASCII là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Ví dụ:

>>> b'ABCabc'.isalpha()
đúng
>>> b'ABCabc1'.isalpha()
sai

bytes.isascii()

bytearray.isascii()

Trả về True nếu chuỗi trống hoặc tất cả byte trong chuỗi là ASCII, False nếu ngược lại. Các byte ASCII nằm trong phạm vi 0-0x7F.

Added in version 3.7.

bytes.isdigit()

bytearray.isdigit()

Trả về True nếu tất cả byte trong chuỗi là các chữ số thập phân ASCII và chuỗi không trống, nếu không thì trả về False. Các chữ số thập phân ASCII là các giá trị byte trong chuỗi b'0123456789'.

Ví dụ:

>>> b'1234'.isdigit()
đúng
>>> b'1.23'.isdigit()
sai

bytes.islower()

bytearray.islower()

Trả về True nếu có ít nhất một ký tự ASCII viết thường trong chuỗi và không có ký tự ASCII viết hoa, nếu không thì trả về False.

Ví dụ:

>>> b'hello world'.iswer()
đúng
>>> b'Xin chào thế giới'.iswer()
sai

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyz'. Các ký tự ASCII viết hoa là các giá trị byte trong chuỗi b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.isspace()

bytearray.isspace()

Trả về True nếu tất cả byte trong chuỗi là khoảng trắng ASCII và chuỗi không trống, ngược lại là False. Ký tự khoảng trắng ASCII là các giá trị byte trong chuỗi b' \t\n\r\x0b\f' (dấu cách, tab, dòng mới, xuống dòng, tab dọc, nguồn cấp dữ liệu biểu mẫu).

bytes.istitle()

bytearray.istitle()

Trả về True nếu chuỗi là tiêu đề ASCII và chuỗi không trống, ngược lại là False. Xem bytes.title() để biết thêm chi tiết về định nghĩa của "titlecase".

Ví dụ:

>>> b'Hello World'.istitle()
đúng
>>> b'Xin chào thế giới'.istitle()
sai

bytes.isupper()

bytearray.isupper()

Trả về True nếu có ít nhất một ký tự ASCII chữ cái viết hoa trong chuỗi và không có ký tự ASCII viết thường, False nếu không.

Ví dụ:

>>> b'HELLO WORLD'.isupper()
đúng
>>> b'Xin chào thế giới'.isupper()
sai

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyz'. Các ký tự ASCII viết hoa là các giá trị byte trong chuỗi b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.lower()

bytearray.lower()

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

Ví dụ:

>>> b'Xin chào thế giới'.low()
b'xin chào thế giới'

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyz'. Các ký tự ASCII viết hoa là các giá trị byte trong chuỗi b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

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 universal newlines để chia dòng. Ngắt dòng không được đưa vào danh sách kết quả trừ khi keepends được đưa ra và đúng.

Ví dụ:

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
[b'ab c', b'', b'de fg', b'kl']
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

Không giống như split() khi cung cấp một chuỗi phân cách sep, phương thức này trả về một danh sách trống cho chuỗi trống và việc ngắt dòng ở đầu cuối không dẫn đến một dòng bổ sung:

>>> b"".split(b'\n'), b"Hai dòng\n".split(b'\n')
([b''], [b'Hai dòng', b''])
>>> b"".splitlines(), b"Một dòng\n".splitlines()
([], [b'Một dòng'])

bytes.swapcase()

bytearray.swapcase()

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

>>> b'Xin chào thế giới'.swapcase()
b'xin chào thế giới'

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyz'. Các ký tự ASCII viết hoa là các giá trị byte trong chuỗi b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Không giống như str.swapcase(), bin.swapcase().swapcase() == bin luôn là trường hợp dành cho các phiên bản nhị phân. Chuyển đổi chữ hoa chữ thường 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 thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.title()

bytearray.title()

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 không được mã hóa sẽ không được sửa đổi.

Ví dụ:

>>> b'Xin chào thế giới'.title()
b'Xin chào thế giới'

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyz'. Các ký tự ASCII viết hoa là các giá trị byte trong chuỗi b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Tất cả các giá trị byte khác đều không được mã hóa.

Thuật toán sử dụng định nghĩa đơn giản, độc lập với 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 này có tác dụng trong nhiều ngữ cảnh nhưng nó có nghĩa là dấu nháy đơn trong cách viết tắt và sở hữu tạo thành ranh giới từ, điều này có thể không mang lại kết quả như mong muốn:

>>> b"Họ là bạn của Bill đến từ Vương quốc Anh".title()
b"Họ là bạn của Bill đến từ Anh"

Có thể xây dựng cách giải quyết cho dấu nháy đơn bằng cách sử dụng biểu thức chính quy

>>> nhập lại
>>> (các) chữ cái tiêu đề def:
... return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
... lambda mo: mo.group(0)[0:1].upper() +
... mo.group(0)[1:].low(),
... s)
...
>>> titlecase(b"họ là bạn của Bill.")
b "Họ là bạn của Bill."

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.upper()

bytearray.upper()

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 bản sao chữ hoa tương ứng của chúng.

Ví dụ:

>>> b'Hello World'.upper()
b'HELLO WORLD'

Các ký tự ASCII chữ thường là các giá trị byte trong chuỗi b'abcdefghijklmnopqrstuvwxyz'. Các ký tự ASCII viết hoa là các giá trị byte trong chuỗi b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Ghi chú

Phiên bản bytearray của phương thức này not hoạt động tại chỗ - nó luôn tạo ra một đối tượng mới, ngay cả khi không có thay đổi nào được thực hiện.

bytes.zfill(width, /)

bytearray.zfill(width, /)

Trả về một bản sao của chuỗi bên trái chứa đầy các chữ số ASCII b'0' để tạo thành một chuỗi có độ dài width. Tiền tố dấu hiệu dẫn đầu (b'+'/ b'-') được xử lý bằng cách chèn phần đệm after ký tự dấu hiệu thay vì trước đó. Đối với các đối tượng bytes, chuỗi ban đầu được trả về nếu width nhỏ hơn hoặc bằng len(seq).

Ví dụ:

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

Ghi chú

Phiên bản bytearray của phương thức này not 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 kiểu printf

Ghi chú

Các thao tác định dạng được mô tả ở đây có nhiều điểm khác biệt 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 gói nó trong một bộ.

Các đối tượng byte (bytes/bytearray) có một thao tác tích hợp duy nhất: toán tử % (modulo). Điều này còn được gọi là toán tử byte formatting hoặc interpolation. Cho format % values (trong đó format là đối tượng byte), thông số chuyển đổi % trong format được thay thế bằng 0 hoặc nhiều phần tử của values. Hiệu ứng này tương tự như việc sử dụng sprintf() trong ngôn ngữ C.

Nếu format yêu cầu một đối số duy nhất, values có thể là một đối tượng không phải là một bộ. [5] Mặt khác, values phải là một bộ dữ liệu có chính xác số lượng mụ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).

Công cụ xác định chuyển đổi chứa hai ký tự trở lên và có các thành phần sau, phải xuất hiện theo thứ tự sau:

1. Ký tự '%', đánh dấu sự bắt đầu của bộ xác định.

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

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à '*' (dấu hoa thị), chiều rộng thực tế được đọc từ phần tử tiếp theo của bộ dữ liệu trong values và đối tượng cần chuyển đổi sẽ xuất hiện sau độ 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 cung cấp dưới dạng '.' (dấu chấm), theo sau là độ chính xác. Nếu được chỉ định là '*' (dấu hoa thị), độ chính xác thực tế sẽ được đọc từ phần tử tiếp theo của bộ dữ liệu trong values và giá trị cần chuyển đổi sẽ 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 must sẽ bao gồm khóa ánh xạ được đặt trong ngoặc đơn vào từ điển đó được chèn ngay sau ký tự '%'. Khóa ánh xạ chọn giá trị cần định dạng từ ánh xạ. Ví dụ:

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

Trong trường hợp này, không có thông số xác định * nào có thể xuất hiện ở một đị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à:

Cờ	Ý nghĩa
'#'	Việc chuyển đổi giá trị sẽ sử dụng "dạng thay thế" (được xác định bên dưới).
'0'	Việc chuyển đổi sẽ được đệm bằng 0 đối với các giá trị số.
'-'	Giá trị chuyển đổi được điều chỉnh trái (ghi đè chuyển đổi '0' nếu cả hai đều được cung cấp).
' '	(dấu cách) Phải để trống trước số dương (hoặc chuỗi trống) do chuyển đổi có dấu tạo ra.
'+'	Ký tự dấu ('+' hoặc '-') sẽ đứng trước quá trình chuyển đổi (ghi đè cờ "dấu cách").

Công cụ sửa đổi độ dài (h, l hoặc L) có thể xuất hiện nhưng bị bỏ qua vì nó không cần thiết đối với Python -- ví dụ: %ld giống hệt %d.

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

Chuyển đổi	Ý nghĩa	Ghi chú
'd'	Số thập phân có dấu số nguyên.
'i'	Số thập phân có dấu số nguyên.
'o'	Giá trị bát phân có dấu.	(1)
'u'	Loại lỗi thời -- nó giống hệt với 'd'.	(8)
'x'	Hệ thập lục phân có dấu (chữ thường).	(2)
'X'	Ký hiệu thập lục phân (chữ hoa).	(2)
'e'	Định dạng số mũ dấu phẩy động (chữ thường).	(3)
'E'	Định dạng số mũ dấu phẩy động (chữ hoa).	(3)
'f'	Định dạng thập phân dấu phẩy động.	(3)
'F'	Định dạng thập phân dấu phẩy động.	(3)
'g'	Định dạng dấu phẩy động. Sử dụng định dạng hàm 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ì sử dụng định dạng thập phân.	(4)
'G'	Định dạng dấu phẩy động. Sử dụng định dạng hàm 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ì sử dụng định dạng thập phân.	(4)
'c'	Byte đơn (chấp nhận các đối tượng số nguyên hoặc byte đơn).
'b'	Byte (bất kỳ đối tượng nào theo sau buffer protocol hoặc có __bytes__()).	(5)
's'	's' là bí danh của 'b' và chỉ nên được sử dụng cho cơ sở mã Python2/3.	(6)
'a'	Byte (chuyển đổi bất kỳ đối tượng Python nào bằng repr(obj).encode('ascii', 'backslashreplace')).	(5)
'r'	'r' là bí danh của 'a' và chỉ nên được sử dụng cho cơ sở mã Python2/3.	(7)
'%'	Không có đối số nào được chuyển đổi, dẫn đến ký tự '%' trong kết quả.

Ghi chú:

1. Dạng thay thế làm cho bộ xác định bát phân hàng đầu ('0o') được chèn trước chữ số đầu tiên.

2. Dạng thay thế khiến một '0x' hoặc '0X' đứng đầu (tùy thuộc vào việc định dạng 'x' hay 'X' được sử dụng) được chèn 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.

   Độ 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ư bình thường.

   Độ 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à N, đầu ra sẽ bị cắt ngắn thành các ký tự N.

6. b'%s' không được dùng nữa nhưng sẽ không bị xóa trong loạt 3.x.

7. b'%r' không được dùng nữa nhưng sẽ không bị xóa trong loạt 3.x.

8. Xem PEP 237.

Ghi chú

Phiên bản bytearray của phương thức này not 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

Added in version 3.5.

Lượt xem bộ nhớ

Đối tượng memoryview cho phép mã Python truy cập dữ liệu nội bộ của đối tượng hỗ trợ buffer protocol mà không cần sao chép.

class memoryview(object)

Tạo một memoryview tham chiếu đến object. object 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 bytes và bytearray.

Zz000zz có khái niệm về element, là đơn vị bộ nhớ nguyên tử được xử lý bởi object ban đầu. Đối với nhiều loại đơn giản như bytes và bytearray, một phần tử là một byte đơn, nhưng các loại khác như array.array có thể có các phần tử lớn hơn.

len(view) bằng độ dài của tolist, đây là biểu diễn danh sách lồng nhau của chế độ xem. Nếu view.ndim = 1, số này bằng số phần tử trong chế độ xem.

Thay đổi trong phiên bản 3.12: Nếu view.ndim == 0, len(view) hiện tăng TypeError thay vì trả về 1.

Thuộc tính itemsize sẽ cung cấp cho bạn số byte trong một phần tử.

Zz000zz hỗ trợ cắt và lập chỉ mục để hiển thị dữ liệu của nó. Việc cắt một chiều sẽ dẫn đến một khung nhìn phụ:

>>> v = Memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<bộ nhớ tại 0x7f3ddc9f4350>
>>> byte(v[1:4])
b'bce'

Nếu format là một trong những công cụ xác định định dạng gốc từ mô-đun struct, thì việc lập chỉ mục bằng một số nguyên hoặc một bộ số nguyên cũng được hỗ trợ và trả về một element với loại chính xác. Chế độ 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ộ số nguyên. Chế độ 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. Chế độ 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:

>>> nhập mảng
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = viewview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

Nếu đối tượng cơ bản có thể ghi được, thì chế độ xem bộ nhớ sẽ hỗ trợ gán lát cắt một chiều. Không được phép thay đổi kích thước:

>>> dữ liệu = bytearray(b'abcefg')
>>> v = bộ nhớview(dữ liệu)
>>> v.readonly
sai
>>> v[0] = ord(b'z')
>>> dữ liệu
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> dữ liệu
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin>", dòng 1, trong <module>
ValueError: gán bộ nhớ: lvalue và rvalue có cấu trúc khác nhau
>>> v[2:6] = b'spam'
>>> dữ liệu
bytearray(b'z1spam')

Chế độ xem bộ nhớ một chiều của loại hashable (chỉ đọc) có định dạng 'B', 'b' hoặc 'c' cũng có thể băm được. Hàm băm được định nghĩa là hash(m) == hash(m.tobytes()):

>>> v = Memoryview(b'abcefg')
>>> hàm băm(v) == hàm băm(b'abcefg')
đúng
>>> hàm băm(v[2:4]) == hàm băm(b'ce')
đúng
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
đúng

Thay đổi trong phiên bản 3.3: Giờ đây, chế độ 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 là hashable.

Thay đổi trong phiên bản 3.4: Memoryview hiện đã được đăng ký tự động với collections.abc.Sequence

Thay đổi trong phiên bản 3.5: giờ đây các lượt xem bộ nhớ có thể được lập chỉ mục với bộ số nguyên.

Thay đổi trong phiên bản 3.14: bộ nhớ xem bây giờ là một generic type.

memoryview có một số phương pháp:

__eq__(exporter)

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

Đối với tập hợp con của chuỗi định dạng struct hiện được tolist() hỗ trợ, v và w bằng nhau nếu v.tolist() == w.tolist():

>>> nhập mảng
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = viewview(a)
>>> y = viewview(b)
>>> x == a == y == b
đúng
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
đúng
>>> z = y[::-2]
>>> z == c
đúng
>>> z.tolist() == c.tolist()
đúng

Nếu một trong hai chuỗi định dạng không được mô-đun struct hỗ trợ thì các đối tượng sẽ luôn so sánh là không bằng nhau (ngay cả khi chuỗi định dạng và nội dung bộ đệm giống hệt nhau):

>>> từ ctypes nhập BigEndianStructure, c_long
>>> lớp BEPoint(BigEndianStructure):
... _fields_ = [("x", c_long), ("y", c_long)]
...
>>> điểm = BEPoint(100, 200)
>>> a = Memoryview(điểm)
>>> b = Memoryview(điểm)
>>> một == điểm
sai
>>> a == b
sai

Lưu ý rằng, giống như các số có dấu phẩy động, v is w có not ngụ ý v == w cho 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ô không quan tâm đến định dạng mục và cấu trúc mảng logic.

tobytes(order='C')

Trả về dữ liệu trong bộ đệm dưới dạng chuỗi byte. Điều này tương đương với việc gọi hàm tạo bytes trên chế độ xem bộ nhớ.

>>> m = Memoryview(b"abc")
>>> m.tobyte()
b'abc'
>>> byte(m)
b'abc'

Đố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. tobytes() hỗ trợ tất cả các chuỗi định dạng, bao gồm cả những chuỗi không có trong cú pháp mô-đun struct.

Added in version 3.8: order có thể là {'C', 'F', 'A'}. Khi order là 'C' hoặc 'F', dữ liệu của mảng ban đầu được chuyển đổi sang thứ tự C hoặc Fortran. Đối với các chế độ xem liền kề, 'A' trả về 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 tiên. order=None giống với order='C'.

hex(*, bytes_per_sep=1)

hex(sep, bytes_per_sep=1)

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.

>>> m = Memoryview(b"abc")
>>> m.hex()
'616263'

Added in version 3.5.

Thay đổi trong phiên bản 3.8: Tương tự như bytes.hex(), memoryview.hex() 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ử.

>>> bộ nhớview(b'abc').tolist()
[97, 98, 99]
>>> nhập mảng
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = viewview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

Thay đổi trong phiên bản 3.3: tolist() hiện hỗ trợ tất cả các định dạng gốc ký tự đơn trong cú pháp mô-đun struct cũng như các biểu diễn đa chiều.

toreadonly()

Trả về phiên bản chỉ đọc của đối tượng Memoryview. Đối tượng MemoryView ban đầu không thay đổi.

>>> m = Memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[97, 98, 99]
>>>mm[0] = 42
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin>", dòng 1, trong <module>
TypeError: không thể sửa đổi bộ nhớ chỉ đọc
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]

Added in version 3.8.

release()

Giải phóng bộ đệm cơ bản do đối tượng MemoryView hiển thị. 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ụ: bytearray sẽ tạm thời cấm thay đổi kích thước); do đó, gọi Release() sẽ rất hữu ích để loại bỏ những hạn chế này (và giải phóng mọi tài nguyên đang treo) càng sớm càng tốt.

Sau khi phương thức này được gọi, mọi thao tác tiếp theo trên khung nhìn sẽ tạo ra ValueError (ngoại trừ chính release() có thể được gọi nhiều lần):

>>> m = Memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin>", dòng 1, trong <module>
ValueError: hoạt động bị cấm trên đối tượng xem bộ nhớ được phát hành

Giao thức quản lý ngữ cảnh có thể được sử dụng để đạt được hiệu quả tương tự bằng cách sử dụng câu lệnh with

>>> với Memoryview(b'abc') là m:
... m[0]
...
97
>>> m[0]
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin>", dòng 1, trong <module>
ValueError: hoạt động bị cấm trên đối tượng xem bộ nhớ được phát hành

Added in version 3.2.

cast(format, /)

cast(format, shape, /)

Truyền chế độ xem bộ nhớ sang định dạng hoặc hình dạng mới. shape mặc định là [byte_length//new_itemsize], có nghĩa là chế độ xem kết quả sẽ là một chiều. Giá trị trả về là một khung nhìn 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-contiguous và C-liền kề -> 1D.

Định dạng đích được giới hạn ở định dạng gốc một phần tử theo cú pháp struct. 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. Lưu ý rằng tất cả độ dài byte có thể phụ thuộc vào hệ điều hành.

Truyền 1D/dài tới 1D/byte không dấu:

>>> nhập mảng
>>> a = array.array('l', [1,2,3])
>>> x = viewview(a)
>>> x.format
'tôi'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbyte
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbyte
24

Truyền 1D/byte không dấu sang 1D/char:

>>> b = bytearray(b'zyz')
>>> x = bộ nhớview(b)
>>> x[0] = b'a'
Traceback (cuộc gọi gần đây nhất):
  ...
TypeError: Memoryview: loại không hợp lệ cho định dạng 'B'
>>> y = x.cast('c')
>>> y[0] = b'a'
>>>b
bytearray(b'ayz')

Truyền 1D/byte thành 3D/ints thành 1D/chared char:

>>> nhập cấu trúc
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = bộ nhớview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'tôi'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbyte
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbyte
48

Truyền 1D/dài không dấu sang 2D/dài không dấu:

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = bộ nhớview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbyte
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

Added in version 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 tới chế độ xem byte.

count(value, /)

Đếm số lần xuất hiện của value.

Added in version 3.14.

index(value, start=0, stop=sys.maxsize, /)

Trả về chỉ mục của lần xuất hiện đầu tiên của value (tại hoặc sau chỉ mục start và trước chỉ mục stop).

Tăng ValueError nếu không tìm thấy value.

Added in version 3.14.

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:

>>> b = bytearray(b'xyz')
>>> m = viewview(b)
>>> m.obj là b
đúng

Added in version 3.3.

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes()). Đâ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 len(m):

>>> nhập mảng
>>> a = array.array('i', [1,2,3,4,5])
>>> m = viewview(a)
>>> len(m)
5
>>> m.nbyte
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbyte
12
>>> len(y.tobytes())
12

Mảng đa chiều:

>>> nhập cấu trúc
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = bộ nhớview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0,0, 1,5, 3,0, 4,5], [6,0, 7,5, 9,0, 10,5], [12,0, 13,5, 15,0, 16,5]]
>>> len(y)
3
>>> y.nbyte
96

Added in version 3.3.

readonly

Một bool cho biết bộ nhớ có ở chế độ chỉ đọc hay không.

format

Một chuỗi chứa định dạng (theo kiểu mô-đun struct) cho từng thành phần trong dạng xem. Chế độ xem bộ nhớ có thể được tạo từ các nhà xuất khẩu với các chuỗi định dạng tùy ý, nhưng một số phương thức (ví dụ: tolist()) bị hạn chế ở các định dạng phần tử đơn gốc.

Thay đổi trong phiên bản 3.3: định dạng 'B' hiện được xử lý theo cú pháp mô-đun struct. Điều này có nghĩa là memoryview(b'abc')[0] == b'abc'[0] == 97.

itemsize

Kích thước tính bằng byte của từng phần tử của Memoryview:

>>> nhập mảng, cấu trúc
>>> m = Memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
đúng

ndim

Một số nguyên cho biết bộ nhớ đại diện cho bao nhiêu chiều của mảng đa chiều.

shape

Một bộ số nguyên có độ dài ndim tạo ra hình dạng của bộ nhớ dưới dạng mảng N chiều.

Thay đổi trong phiên bản 3.3: Một bộ trống thay vì None khi ndim = 0.

strides

Một bộ số nguyên có độ dài ndim cho biết 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ì None khi ndim = 0.

suboffsets

Được sử dụng nội bộ cho mảng kiểu PIL. Giá trị chỉ mang tính thông tin.

c_contiguous

Một bool cho biết bộ nhớ có phải là C-contiguous hay không.

Added in version 3.3.

f_contiguous

Một bool cho biết bộ nhớ có phải là Fortran contiguous hay không.

Added in version 3.3.

contiguous

Một bool cho biết bộ nhớ có phải là contiguous hay không.

Added in version 3.3.

Để biết thông tin về độ an toàn luồng của các đối tượng memoryview trong free-threaded build, hãy xem An toàn luồng cho các đối tượng MemoryView.

Đặt các loại --- set, frozenset

Đối tượng set là một tập hợp không có thứ tự của các đối tượng hashable riêng biệt. Các cách sử dụng phổ biến bao gồm kiểm tra tư cách thành viên, loại bỏ các bản sao khỏi một chuỗi và tính toán các phép toán như giao, hợp, sai phân và sai phân đối xứng. (Đối với các vùng chứa khác, hãy xem các lớp dict, list và tuple tích hợp sẵn và mô-đun collections.)

Giống như các bộ sưu tập khác, các bộ hỗ trợ x in set, len(set) và for x in set. Là một bộ sưu tập không có thứ tự, các bộ không ghi lại 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 lát hoặc các hành vi giống như trình tự khác.

Hiện tại có hai loại bộ cài sẵn là set và frozenset. Loại set có thể thay đổi --- nội dung có thể được thay đổi bằng các phương thức như add() và remove(). 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 phần tử của tập hợp khác. Loại frozenset là bất biến và hashable --- nội dung của nó không thể thay đổi sau khi được tạo; do đó nó có thể được sử dụng làm khóa từ điển hoặc như một phần tử của tập hợp khác.

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, ví dụ: {'jack', 'sjoerd'}, ngoài hàm tạo set.

Hàm tạo của cả hai lớp đều hoạt động như nhau:

class set(iterable=(), /)

class frozenset(iterable=(), /)

Trả về một tập hợp mới hoặc đối tượng Frozenset có các phần tử được lấy từ iterable. Các phần tử của một tập hợp phải là hashable. Để biểu diễn các tập hợp, các tập hợp bên trong phải là đối tượng frozenset. Nếu iterable không được chỉ định, một tập hợp trống mới sẽ đượ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: {'jack', 'sjoerd'}

• Sử dụng mức độ hiểu đã đặt: {c for c in 'abracadabra' if c not in 'abc'}

• Sử dụng hàm tạo kiểu: set(), set('foobar'), set(['a', 'b', 'foo'])

Các phiên bản của set và frozenset cung cấp các hoạt động sau:

len(s)

Trả về số phần tử trong tập hợp s (cardinality của s).

x in s

Kiểm tra x để trở thành thành viên trong s.

x not in s

Kiểm tra x xem có phải là thành viên không trong s.

frozenset.isdisjoint(other, /)

set.isdisjoint(other, /)

Trả về True nếu tập hợp không có phần tử nào chung với other. Các tập hợp là rời nhau khi và chỉ nếu giao của chúng là tập rỗng.

frozenset.issubset(other, /)

set.issubset(other, /)

set <= other

Kiểm tra xem mọi phần tử trong tập hợp có nằm trong other hay không.

set < other

Kiểm tra xem tập hợp này có phải là tập con thực sự của other hay không, tức là set <= other and set != other.

frozenset.issuperset(other, /)

set.issuperset(other, /)

set >= other

Kiểm tra xem mọi phần tử trong other có nằm trong tập hợp hay không.

set > other

Kiểm tra xem bộ này có phải là siêu bộ thích hợp của other hay không, tức là set >= other and set != other.

frozenset.union(*others)

set.union(*others)

set | other | ...

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.

frozenset.intersection(*others)

set.intersection(*others)

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.

frozenset.difference(*others)

set.difference(*others)

set - other - ...

Trả về một tập hợp mới với các phần tử trong tập hợp này không có trong các tập hợp khác.

frozenset.symmetric_difference(other, /)

set.symmetric_difference(other, /)

set ^ other

Trả về một tập hợp mới có các phần tử trong tập hợp đó hoặc other nhưng không phải cả hai.

frozenset.copy()

set.copy()

Trả lại một bản sao nông của bộ này.

Lưu ý, các phiên bản không phải toán tử của các phương thức union(), intersection(), difference(), symmetric_difference(), issubset() và issuperset() sẽ chấp nhận bất kỳ đối số nào có thể lặp lại. 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 phải được đặt. Điều này ngăn cản việc xây dựng dễ bị lỗi như set('abc') & 'cbs' và thay vào đó là set('abc').intersection('cbs') dễ đọc hơn.

Cả set và frozenset đều hỗ trợ thiết lập để so sánh. Hai tập hợp bằng nhau khi và chỉ nếu mọi phần tử của mỗi tập hợp đều chứa trong tập kia (mỗi tập hợp là tập con của tập kia). Một tập hợp nhỏ hơn một tập hợp khác khi và chỉ nếu tập hợp thứ nhất 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). Một tập hợp lớn hơn một tập hợp khác khi và chỉ khi tậ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).

Các phiên bản của set được so sánh với các phiên bản của frozenset dựa trên các thành viên của chúng. Ví dụ: set('abc') == frozenset('abc') trả về True và set('abc') in set([frozenset('abc')]) cũng vậy.

So sánh tập hợp con và đẳng thức không khái quát hóa thành hàm sắp xếp tổng. Ví dụ: bất kỳ hai tập hợp rời rạc khác trống nào đều không bằng nhau và không phải là tập con của nhau, vì vậy all của tập hợp sau đây trả về False: a<b, a==b hoặc a>b.

Vì các tập hợp chỉ xác định thứ tự một phần (các mối quan hệ tập hợp con), nên đầu ra của phương thức list.sort() không được xác định cho danh sách các tập hợp.

Các phần tử tập hợp, như khóa từ điển, phải là hashable.

Các phép toán nhị phân trộn các phiên bản set với frozenset trả về loại toán hạng đầu tiên. Ví dụ: frozenset('ab') | set('bc') trả về một phiên bản của frozenset.

Bảng sau liệt kê các thao tác có sẵn cho set không áp dụng cho các phiên bản bất biến của frozenset:

set.update(*others)

set |= other | ...

Cập nhật bộ này, thêm các phần tử từ tất cả các phần tử khác.

set.intersection_update(*others)

set &= other & ...

Cập nhật tập hợp, chỉ giữ lại các phần tử tìm thấy trong đó và tất cả các phần tử khác.

set.difference_update(*others)

set -= other | ...

Cập nhật bộ này, loại bỏ các phần tử được tìm thấy trong bộ khác.

set.symmetric_difference_update(other, /)

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 giữ lại các phần tử được tìm thấy trong cả hai tập hợp.

set.add(elem, /)

Thêm phần tử elem vào tập hợp.

set.remove(elem, /)

Loại bỏ phần tử elem khỏi tập hợp. Tăng KeyError nếu elem không có trong tập hợp.

set.discard(elem, /)

Xóa phần tử elem khỏi bộ nếu nó có mặt.

set.pop()

Xóa và trả về một phần tử tùy ý khỏi tập hợp. Tăng KeyError nếu tập hợp trống.

set.clear()

Loại bỏ 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 update(), intersection_update(), difference_update() và symmetric_difference_update() 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 __contains__(), remove() và discard() có thể là một tập hợp. Để hỗ trợ tìm kiếm một tập hợp đông lạnh tương đương, một tập hợp tạm thời được tạo từ elem.

Xem thêm

Để biết thông tin chi tiết về đảm bảo an toàn luồng cho các đối tượng set, hãy xem An toàn luồng cho các đối tượng được thiết lập.

Các loại ánh xạ --- dict

Đối tượng mapping ánh xạ các giá trị hashable tới các đối tượng tùy ý. Ánh xạ là các đối tượng có thể thay đổi. Hiện tại chỉ có một loại ánh xạ tiêu chuẩn là dictionary. (Đối với các vùng chứa khác, hãy xem các lớp list, set và tuple tích hợp sẵn và mô-đun collections.)

Khóa của từ điển là các giá trị tùy ý almost. Các giá trị không phải là hashable, 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ị chứ không phải theo nhận dạng đối tượng) có thể không được sử dụng làm khóa. Các giá trị so sánh bằng nhau (chẳng hạn như 1, 1.0 và True) 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 tập hợp đối số từ khóa có thể trống.

Từ điển có thể được tạo bằng nhiều cách:

• Sử dụng danh sách các cặp key: value được phân tách bằng dấu phẩy trong dấu ngoặc nhọn: {'jack': 4098, 'sjoerd': 4127} hoặc {4098: 'jack', 4127: 'sjoerd'}

• Sử dụng khả năng hiểu chính tả: {}, {x: x ** 2 for x in range(10)}

• Sử dụng hàm tạo kiểu: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

Nếu không có đối số vị trí nào được đưa ra thì một từ điển trống sẽ được tạo. Nếu một đối số vị trí được đưa ra và nó định nghĩa một phương thức keys(), thì một từ điển sẽ được tạo bằng cách gọi __getitem__() trên đối số với mỗi khóa được trả về từ phương thức đó. Nếu không, đối số vị trí phải là đối tượng iterable. Mỗi mục trong iterable phải là một iterable có chính xác hai phần tử. Phần tử đầu tiên của mỗi mục trở thành khóa trong từ điển mới và phần tử thứ hai trở thành giá trị tương ứng. Nếu một khóa xuất hiện nhiều lần thì 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 đối số từ khóa được đưa ra, đố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 khóa được thêm đã có sẵn thì giá trị từ đối số từ khóa sẽ thay thế giá trị từ đối số vị trí.

Từ điển so sánh bằng nhau khi và chỉ khi chúng có cùng cặp (key, value) (bất kể thứ tự). So sánh thứ tự ('<', '<=', '>=', '>') nâng cao TypeError. Để minh họa việc tạo từ điển và sự bình đẳng, các ví dụ sau đều trả về một từ điển bằng {"one": 1, "two": 2, "three": 3}:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'một': 1, 'hai': 2, 'ba': 3}
>>> c = dict(zip(['một', 'hai', 'ba'], [1, 2, 3]))
>>> d = dict([('hai', 2), ('một', 1), ('ba', 3)])
>>> e = dict({'ba': 3, 'một': 1, 'hai': 2})
>>> f = dict({'one': 1, 'ba': 3}, two=2)
>>> a == b == c == d == e == f
đúng

Việc cung cấp đố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ệ. Nếu không, bất kỳ khóa hợp lệ nào cũng có thể được sử dụng.

Từ điển giữ nguyê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 khóa được thêm sau khi xóa sẽ được chèn vào cuối.

>>> d = {"một": 1, "hai": 2, "ba": 3, "bốn": 4}
>>> d
{'một': 1, 'hai': 2, 'ba': 3, 'bốn': 4}
>>> danh sách(d)
['một', 'hai', 'ba', 'bốn']
>>> danh sách(d.values())
[1, 2, 3, 4]
>>> d["một"] = 42
>>> d
{'một': 42, 'hai': 2, 'ba': 3, 'bốn': 4}
>>> del d["hai"]
>>> d["hai"] = Không có
>>> d
{'một': 42, 'ba': 3, 'bốn': 4, 'hai': Không có}

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à chi tiết triển khai của CPython từ phiên bản 3.6.

Đây là những thao tác mà từ điển hỗ trợ (và do đó, các loại ánh xạ tùy chỉnh cũng sẽ hỗ trợ):

list(d)

Trả về danh sách tất cả các khóa được sử dụng trong từ điển d.

len(d)

Trả về số mục trong từ điển d.

d[key]

Trả về mục d bằng key key. Tăng KeyError nếu key không có trên bản đồ.

Nếu một lớp con của dict xác định một phương thức __missing__() và key không có mặt, thì thao tác d[key] sẽ gọi phương thức đó với khóa key làm đối số. Sau đó, thao tác d[key] trả về hoặc tăng bất cứ thứ gì được trả về hoặc tăng lên bởi lệnh gọi __missing__(key). Không có thao tác hoặc phương thức nào khác gọi __missing__(). Nếu __missing__() không được xác định, KeyError sẽ được nâng lên. __missing__() phải là một phương thức; nó không thể là một biến thể hiện:

>>> Bộ đếm lớp (dict):
... def __missing__(self, key):
... trả về 0
...
>>> c = Bộ đếm()
>>> c['đỏ']
0
>>> c['đỏ'] += 1
>>> c['đỏ']
1

Ví dụ trên cho thấy một phần quá trình triển khai collections.Counter. Một phương pháp __missing__() khác được collections.defaultdict sử dụng.

d[key] = value

Đặt d[key] thành value.

del d[key]

Xóa d[key] khỏi d. Tăng KeyError nếu key không có trên bản đồ.

key in d

Trả về True nếu d có khóa key, nếu không thì False.

key not in d

Tương đương với not key in d.

iter(d)

Trả về một trình lặp qua các khóa của từ điển. Đây là lối tắt cho iter(d.keys()).

clear()

Xóa tất cả các mục khỏi từ điển.

copy()

Trả lại một bản sao nông của từ điển.

classmethod fromkeys(iterable, value=None, /)

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

fromkeys() là một phương thức lớp trả về một từ điển mới. value mặc định là None. Tất cả các giá trị chỉ đề cập đến một phiên bản duy nhất, do đó, thông thường sẽ không có ý nghĩa gì khi value trở thành một đối tượng có thể thay đổi, chẳng hạn như một danh sách trống. Để có được các giá trị riêng biệt, thay vào đó hãy sử dụng dict comprehension.

get(key, default=None, /)

Trả về giá trị cho key nếu key có trong từ điển, nếu không thì default. Nếu default không được cung cấp, nó sẽ mặc định là None, do đó phương pháp này không bao giờ tăng KeyError.

items()

Trả về chế độ xem mới của các mục trong từ điển (cặp (key, value)). Xem documentation of view objects.

keys()

Trả về chế độ xem mới về các khóa của từ điển. Xem documentation of view objects.

pop(key, /)

pop(key, default, /)

Nếu key có trong từ điển, hãy xóa nó và trả về giá trị của nó, nếu không thì trả về default. Nếu default không được cung cấp và key không có trong từ điển thì KeyError sẽ được đưa ra.

popitem()

Xóa và trả lại cặp (key, value) khỏi từ điển. Các cặp được trả về theo thứ tự LIFO.

popitem() rất hữu ích để lặp lại triệt để một từ điển, như thường được sử dụng trong các thuật toán tập hợp. Nếu từ điển trống, việc gọi popitem() sẽ tạo ra KeyError.

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, popitem() sẽ trả về một cặp khóa/giá trị tùy ý.

reversed(d)

Trả về một trình vòng lặp ngược trên các khóa của từ điển. Đây là lối tắt cho reversed(d.keys()).

Added in version 3.8.

setdefault(key, default=None, /)

Nếu key có trong từ điển, hãy trả về giá trị của nó. Nếu không, hãy chèn key với giá trị default và trả về default. default mặc định là None.

update(**kwargs)

update(mapping, /, **kwargs)

update(iterable, /, **kwargs)

Cập nhật từ điển với các cặp khóa/giá trị từ mapping hoặc iterable và kwargs, ghi đè các khóa hiện có. Trả về None.

update() chấp nhận một đối tượng khác bằng phương thức keys() (trong trường hợp đó __getitem__() được gọi với mọi khóa được trả về từ phương thứ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 bộ lặp khác có độ dài hai). Nếu đố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ị đó: d.update(red=1, blue=2).

values()

Trả về chế độ xem mới về giá trị của từ điển. Xem documentation of view objects.

Sự so sánh bình đẳng giữa một chế độ xem dict.values() và một chế độ xem khác sẽ luôn trả về False. Điều này cũng áp dụng khi so sánh dict.values() với chính nó:

>>> d = {'a': 1}
>>> d.values() == d.values()
sai

d | other

Tạo một từ điển mới với các khóa và giá trị đã hợp nhất của d và other, cả hai đều phải là từ điển. Các giá trị của other được ưu tiên khi d và other chia sẻ khóa.

Added in version 3.9.

d |= other

Cập nhật từ điển d với các khóa và giá trị từ other, có thể là mapping hoặc iterable của các cặp khóa/giá trị. Các giá trị của other được ưu tiên khi d và other chia sẻ khóa.

Added in version 3.9.

Từ điển và chế độ xem từ điển có thể đảo ngược.

>>> d = {"một": 1, "hai": 2, "ba": 3, "bốn": 4}
>>> d
{'một': 1, 'hai': 2, 'ba': 3, 'bốn': 4}
>>> danh sách(đảo ngược(d))
['bốn', 'ba', 'hai', 'một']
>>> danh sách(đảo ngược(d.values()))
[4, 3, 2, 1]
>>> danh sách(đảo ngược(d.items()))
[('bốn', 4), ('ba', 3), ('hai', 2), ('một', 1)]

Thay đổi trong phiên bản 3.8: Từ điển bây giờ có thể đảo ngược.

Xem thêm

types.MappingProxyType có thể được sử dụng để tạo chế độ xem chỉ đọc của dict.

Xem thêm

Để biết thông tin chi tiết về đảm bảo an toàn luồng cho các đối tượng dict, hãy xem An toàn chủ đề cho các đối tượng dict.

Đối tượng xem từ điển

Các đối tượng được trả về bởi dict.keys(), dict.values() và dict.items() là view objects. Chúng cung cấp chế độ xem động đối với 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 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ố lượng mục trong từ điển.

iter(dictview)

Trả về một trình vòng lặp qua các khóa, giá trị hoặc mục (được biểu thị dưới dạng bộ dữ liệu của (key, value)) 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 (value, key) bằng cách sử dụng zip(): pairs = zip(d.values(), d.keys()). Một cách khác để tạo danh sách tương tự là pairs = [(v, k) for (k, v) in d.items()].

Việc lặp lại các chế độ xem trong khi thêm hoặc xóa các mục trong từ điển có thể gây ra RuntimeError hoặc không thể lặp lại tất cả các mục.

Thay đổi trong phiên bản 3.7: Thứ tự từ điển được đảm bảo là thứ tự chèn.

x in dictview

Trả về True nếu x có trong 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à một bộ (key, value)).

reversed(dictview)

Trả về một trình vòng lặp ngược đối với 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 với thao tác chèn.

Thay đổi trong phiên bản 3.8: Chế độ xem từ điển hiện có thể đảo ngược.

dictview.mapping

Trả về một types.MappingProxyType bao bọc từ điển gốc mà chế độ xem đề cập đến.

Added in version 3.10.

Chế độ xem khóa giống như được đặt vì các mục nhập của chúng là duy nhất và hashable. Chế độ xem mục cũng có các hoạt động giống như tập hợp vì các cặp (khóa, giá trị) là duy nhất và các khóa có thể băm được. Nếu tất cả các giá trị trong chế độ xem mục cũng có thể băm được thì chế độ xem mục có thể tương tác với các tập hợp khác. (Các chế độ xem giá trị không được coi là giống tập hợp vì các mục nhập thường không phải là duy nhất.) Đối với các chế độ xem giống tập hợp, tất cả các hoạt động được xác định cho lớp cơ sở trừu tượng collections.abc.Set đều khả dụng (ví dụ: ==, < hoặc ^). Trong khi sử dụng toán tử tập hợp, các dạng xem giống tập hợp chấp nhận bất kỳ lần lặp nào làm toán hạng khác, không giống như các tập hợp chỉ chấp nhận tập hợp làm đầu vào.

Một ví dụ về cách sử dụng chế độ xem từ điển:

>>> món = {'trứng': 2, 'xúc xích': 1, 'thịt xông khói': 1, 'thư rác': 500}
>>> phím = món ăn.keys()
>>> giá trị = món ăn.values()

>>> # iteration
>>> n = 0
>>> cho val trong các giá trị:
... n += val
...
>>> in(n)
504

>>> # keys và các giá trị được lặp lại theo cùng một thứ tự (thứ tự chèn)
>>> danh sách (phím)
['trứng', 'xúc xích', 'thịt xông khói', 'thư rác']
>>> danh sách (giá trị)
[2, 1, 1, 500]

>>> Các đối tượng # view rất năng động và phản ánh những thay đổi về chính tả
>>> del món ăn['trứng']
>>> del món['xúc xích']
>>> danh sách (phím)
['thịt xông khói', 'thư rác']

>>> hoạt động # set
>>> phím & {'trứng', 'thịt xông khói', 'salad'}
{'thịt xông khói'}
>>> phím ^ {'xúc xích', 'nước trái cây'} == {'nước trái cây', 'xúc xích', 'thịt xông khói', 'spam'}
đúng
>>> phím | ['nước trái cây', 'nước trái cây', 'nước trái cây'] == {'thịt xông khói', 'spam', 'nước trái cây'}
đúng

>>> # get quay lại proxy chỉ đọc cho từ điển gốc
>>> giá trị.mapping
mapsproxy({'bacon': 1, 'spam': 500})
>>> value.mapping['spam']
500

Các loại trình quản lý bối cảnh

Câu lệnh with 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 triển khai 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 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:

contextmanager.__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 trả về bởi phương thức này được liên kết với mã định danh trong mệnh đề as của câu lệnh with bằng trình quản lý bối cảnh này.

Một ví dụ về trình quản lý bối cảnh tự trả về là file object. Các đối tượng tệp tự trả về từ __enter__() để cho phép sử dụng open() làm biểu thức ngữ cảnh trong câu lệnh with.

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 decimal.localcontext(). Những người quản lý này đặt bối cảnh thập phân đang hoạt động thành bản sao của bối cảnh thập phân ban đầu và sau đó trả về 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 nội dung của câu lệnh with mà không ảnh hưởng đến mã bên ngoài câu lệnh with.

contextmanager.__exit__(exc_type, exc_val, exc_tb)

Thoát khỏi bối cảnh thời gian chạy và trả về cờ Boolean cho biết liệu có bất kỳ ngoại lệ nào xảy ra cần bị loại bỏ hay không. Nếu một ngoại lệ xảy ra trong khi thực thi phần thân của câu lệnh with, các đối số sẽ chứa loại ngoại lệ, giá trị và thông tin truy nguyên. Ngược lại, cả ba đối số đều là None.

Trả về giá trị thực từ phương thức này sẽ khiến câu lệnh with loại bỏ ngoại lệ và tiếp tục thực thi với câu lệnh ngay sau câu lệnh with. Nếu không, ngoại lệ sẽ tiếp tục lan truyền sau khi phương thức này thực thi xong.

Nếu phương thức này đưa ra một ngoại lệ trong khi xử lý một ngoại lệ trước đó từ khối with, thì ngoại lệ mới sẽ được đưa ra và ngoại lệ ban đầu được lưu trữ trong thuộc tính __context__ của nó.

Ngoại lệ được truyền vào không bao giờ được kích hoạt lại một cách rõ ràng - thay vào đó, phương thức này phải trả về giá trị sai để cho biết rằng phương thức đã hoàn thành thành công và không muốn loại bỏ ngoại lệ được đưa ra. Điều này cho phép mã quản lý ngữ cảnh dễ dàng phát hiện xem phương thức __exit__() có thực sự thất bại hay không.

Python định nghĩa một số trình quản lý bối cảnh để hỗ trợ đồng bộ hóa luồng dễ dàng, đóng nhanh các tệp hoặc các đối tượng khác và thao tác đơn giản hơn với bối 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 triển khai giao thức quản lý ngữ cảnh. Xem mô-đun contextlib để biết một số ví dụ.

generators và trình trang trí contextlib.contextmanager của Python 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 trang trí contextlib.contextmanager, thì nó sẽ trả về một trình quản lý bối cảnh triển khai các phương thức __enter__() và __exit__() cần thiết, thay vì trình 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ể 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 Python/C API. 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 Python thông thường có thể truy cập được. So với chi phí thiết lập bối cảnh thời gian chạy, chi phí cho việc tra cứu từ điển một lớp là không đáng kể.

Loại chú thích Các loại --- Generic Alias, Union

Các loại tích hợp cốt lõi cho type annotations là Generic Alias và Union.

Loại bí danh chung

Các đối tượng GenericAlias thường được tạo bởi một lớp subscripting. Chúng thường được sử dụng nhiều nhất với container classes, chẳng hạn như list hoặc dict. Ví dụ: list[int] là một đối tượng GenericAlias được tạo bằng cách đăng ký lớp list với đối số int. Các đối tượng GenericAlias chủ yếu được thiết kế để sử dụng với type annotations.

Ghi chú

Nói chung chỉ có thể chỉ số dưới của một lớp nếu lớp đó triển khai phương thức đặc biệt __class_getitem__().

Đối tượng GenericAlias hoạt động như một proxy cho generic type, triển khai parameterized generics.

Đối với một lớp chứa, (các) đối số được cung cấp cho subscription của lớp có thể chỉ ra (các) loại phần tử mà đối tượng chứa. Ví dụ: set[bytes] có thể được sử dụng trong các chú thích kiểu để biểu thị một set trong đó tất cả các phần tử đều thuộc loại bytes.

Đối với một lớp xác định __class_getitem__() nhưng không phải là vùng chứa, (các) đối số được cung cấp cho đăng ký của lớp đó thường sẽ chỉ ra (các) kiểu trả về của một hoặc nhiều phương thức được xác định trên một đối tượng. Ví dụ: regular expressions có thể được sử dụng trên cả kiểu dữ liệu str và kiểu dữ liệu bytes:

• Nếu x = re.search('foo', 'foo'), x sẽ là một đối tượng re.Match trong đó các giá trị trả về của x.group(0) và x[0] đều thuộc loại str. Chúng ta có thể biểu diễn loại đối tượng này trong các chú thích kiểu bằng GenericAlias re.Match[str].

• Nếu y = re.search(b'bar', b'bar'), (lưu ý b cho bytes), y cũng sẽ là một phiên bản của re.Match, nhưng giá trị trả về của y.group(0) và y[0] đều sẽ thuộc loại bytes. Trong chú thích kiểu, chúng tôi sẽ biểu thị nhiều đối tượng re.Match này bằng re.Match[bytes].

Các đối tượng GenericAlias là các thể hiện của lớp types.GenericAlias, lớp này cũng có thể được sử dụng để tạo trực tiếp các đối tượng GenericAlias.

T[X, Y, ...]

Tạo một GenericAlias đại diện cho loại T được tham số hóa theo loại X, Y, v.v. tùy thuộc vào T được sử dụng. Ví dụ: một hàm mong đợi list chứa các phần tử float

trung bình def (giá trị: danh sách [float]) -> float:
    trả về tổng(giá trị) / len(giá trị)

Một ví dụ khác cho các đối tượng mapping, sử dụng dict, là loại chung mong đợi hai tham số loại đại diện cho loại khóa và loại giá trị. Trong ví dụ này, hàm mong đợi một dict với các khóa thuộc loại str và các giá trị thuộc loại int:

def send_post_request(url: str, body: dict[str, int]) -> Không có:
    ...

Các hàm dựng sẵn isinstance() và issubclass() không chấp nhận các loại GenericAlias cho đối số thứ hai của chúng:

>>> isinstance([1, 2], list[str])
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin>", dòng 1, trong <module>
TypeError: đối số isinstance() 2 không thể là đối số chung được tham số hóa

Thời gian chạy Python không thực thi type annotations. Điều này mở rộng đến các kiểu chung và các tham số kiểu của chúng. Khi tạo đối tượng vùng chứa từ GenericAlias, các phần tử trong vùng chứa không được kiểm tra theo loại của chúng. Ví dụ: đoạn mã sau không được khuyến khích nhưng sẽ chạy mà không gặp lỗi:

>>> t = danh sách[str]
>>> t([1, 2, 3])
[1, 2, 3]

Hơn nữa, các tham số loại tổng quát được tham số hóa sẽ xóa trong quá trình tạo đối tượng

>>> t = danh sách[str]
>>> loại(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> loại(l)
<lớp 'danh sách'>

Gọi repr() hoặc str() trên một cái chung sẽ hiển thị loại tham số

>>> đại diện (danh sách [int])
'danh sách[int]'

>>> str(danh sách[int])
'danh sách[int]'

Phương thức __getitem__() của các vùng chứa chung sẽ đưa ra một ngoại lệ để không cho phép các lỗi như dict[str][str]:

>>> dict[str][str]
Traceback (cuộc gọi gần đây nhất):
  ...
TypeError: dict[str] không phải là lớp chung

Tuy nhiên, các biểu thức đó hợp lệ khi sử dụng type variables. Chỉ mục phải có nhiều phần tử như số mục biến loại trong __args__ của đối tượng GenericAlias.

>>> từ cách nhập import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

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 tổng quát được tham số hóa. Danh sách này là không đầy đủ.

• tuple

• list

• dict

• set

• frozenset

• type

• asyncio.Future

• asyncio.Task

• collections.deque

• collections.defaultdict

• collections.OrderedDict

• collections.Counter

• collections.ChainMap

• collections.abc.Awaitable

• collections.abc.Coroutine

• collections.abc.AsyncIterable

• collections.abc.AsyncIterator

• collections.abc.AsyncGenerator

• collections.abc.Iterable

• collections.abc.Iterator

• collections.abc.Generator

• collections.abc.Reversible

• collections.abc.Container

• collections.abc.Collection

• collections.abc.Callable

• collections.abc.Set

• collections.abc.MutableSet

• collections.abc.Mapping

• collections.abc.MutableMapping

• collections.abc.Sequence

• collections.abc.MutableSequence

• collections.abc.ByteString

• collections.abc.MappingView

• collections.abc.KeysView

• collections.abc.ItemsView

• collections.abc.ValuesView

• contextlib.AbstractContextManager

• contextlib.AbstractAsyncContextManager

• dataclasses.Field

• functools.cached_property

• functools.partialmethod

• os.PathLike

• queue.LifoQueue

• queue.Queue

• queue.PriorityQueue

• queue.SimpleQueue

• re.Pattern

• re.Match

• shelve.BsdDbShelf

• shelve.DbfilenameShelf

• shelve.Shelf

• types.MappingProxyType

• weakref.WeakKeyDictionary

• weakref.WeakMethod

• weakref.WeakSet

• weakref.WeakValueDictionary

Thuộc tính đặc biệt của đối tượng GenericAlias

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.

genericalias.__origin__

Thuộc tính này trỏ đến lớp chung không có tham số:

>>> danh sách[int].__origin__
<lớp 'danh sách'>

genericalias.__args__

Thuộc tính này là tuple (có thể có độ dài 1) của các loại chung được truyền cho __class_getitem__() ban đầu của lớp chung:

>>> dict[str, list[int]].__args__
(<class 'str'>, danh sách[int])

genericalias.__parameters__

Thuộc tính này là một bộ dữ liệu được tính toán lười biếng (có thể trống) gồm các biến loại duy nhất được tìm thấy trong __args__:

>>> từ cách nhập import TypeVar

>>> T = TypeVar('T')
>>> danh sách[T].__thông số__
(~T,)

Ghi chú

Đối tượng GenericAlias có tham số typing.ParamSpec có thể không có __parameters__ chính xác sau khi thay thế vì typing.ParamSpec chủ yếu dành cho việc kiểm tra kiểu tĩnh.

genericalias.__unpacked__

Một boolean đúng nếu bí danh đã được giải nén bằng toán tử * (xem TypeVarTuple).

Added in version 3.11.

Xem thêm

PEP 484 - Gợi ý gõ

Giới thiệu khung công tác chú thích kiểu của Python.

PEP 585 - Gõ Generics gợi ý 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 một cách tự nhiên, miễn là chúng triển khai phương thức lớp đặc biệt __class_getitem__().

Thuốc gốc, user-defined generics và typing.Generic

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 trình kiểm tra kiểu tĩnh hiểu được.

Added in version 3.9.

Loại công đoàn

Một đối tượng hợp nhất giữ giá trị của thao tác | (bitwise hoặc) trên nhiều type objects. Những loại này chủ yếu dành cho type annotations. Biểu thức loại kết hợp cho phép cú pháp gợi ý loại rõ ràng hơn so với chỉ số typing.Union.

X | Y | ...

Xác định một đối tượng hợp chứa các kiểu X, Y, v.v. X | Y có nghĩa là X hoặc Y. Nó tương đương với typing.Union[X, Y]. Ví dụ: hàm sau mong đợi một đối số thuộc loại int hoặc float:

hình vuông def(số: int | float) -> int | float:
    số trả về ** 2

Ghi chú

Toán hạng | không thể được sử dụng trong thời gian chạy để xác định các liên kết trong đó một hoặc nhiều thành viên là tham chiếu chuyển tiếp. Ví dụ: int | "Foo", trong đó "Foo" là tham chiếu đến một lớp chưa được xác định, sẽ bị lỗi khi chạy. Đối với các kết hợp bao gồm các tham chiếu chuyển tiếp, hãy trình bày toàn bộ biểu thức dưới dạng một chuỗi, ví dụ: "int | Foo".

union_object == other

Các đối tượng hợp nhất có thể được kiểm tra sự bình đẳng với các đối tượng hợp nhất khác. Chi tiết:

• Công đoàn các đoàn thể bị san phẳng:

  (int | str) | float == int | str | float
  

• Các loại dư thừa được loại bỏ:

  int | str | int == int | str
  

• Khi so sánh các công đoàn, thứ tự bị bỏ qua:

  int | str == str | int
  

• Nó tạo ra các phiên bản của typing.Union:

  int | str == gõ.Union[int, str]
  type(int | str) đang gõ.Union
  

• Các loại tùy chọn có thể được đánh vần là kết hợp với None:

  str | Không có == gõ.Tùy chọn [str]
  

isinstance(obj, union_object)

issubclass(obj, union_object)

Các lệnh gọi tới isinstance() và issubclass() cũng được hỗ trợ với đối tượng hợp nhất:

>>> isinstance("", int | str)
đúng

Tuy nhiên, không thể kiểm tra parameterized generics trong các đối tượng hợp nhất

>>> isinstance(1, int | list[int]) đánh giá # short-circuit
đúng
>>> isinstance([1], int | list[int])
Traceback (cuộc gọi gần đây nhất):
  ...
TypeError: đối số isinstance() 2 không thể là đối số chung được tham số hóa

Loại do người dùng hiển thị cho đối tượng hợp nhất có thể được truy cập từ typing.Union và được sử dụng để kiểm tra isinstance()

>>> nhập gõ
>>> isinstance(int | str, gõ.Union)
đúng
>>> gõ.Union()
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin>", dòng 1, trong <module>
TypeError: không thể tạo phiên bản 'typing.Union'

Ghi chú

Phương thức __or__() cho các đối tượng loại đã được thêm vào để hỗ trợ cú pháp X | Y. Nếu siêu dữ liệu triển khai __or__(), Liên minh có thể ghi đè lên nó:

>>> lớp M(loại):
... def __or__(bản thân, người khác):
... quay lại "Xin chào"
...
>>> lớp C(siêu lớp=M):
... vượt qua
...
>>> C | int
'Xin chào'
>>> int | C
int | C

Xem thêm

PEP 604 -- PEP đề xuất cú pháp X | Y và loại Union.

Added in version 3.10.

Thay đổi trong phiên bản 3.14: Các đối tượng Union hiện là phiên bản của typing.Union. Trước đây, chúng là phiên bản của types.UnionType, vẫn là bí danh của typing.Union.

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 những thứ 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ô-đun là truy cập thuộc tính: m.name, trong đó m là một mô-đun và name truy cập 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 import không phải, nói đúng ra, là một thao tác trên một đối tượng mô-đun; import foo không yêu cầu một đối tượng mô-đun có tên foo tồn tại, thay vào đó, nó yêu cầu một definition (bên ngoài) cho một mô-đun có tên foo ở đâu đó.)

Một thuộc tính đặc biệt của mỗi mô-đun là __dict__. Đâ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 __dict__ (bạn có thể viết m.__dict__['a'] = 1, định nghĩa m.a là 1, nhưng bạn không thể viết m.__dict__ = {}). Không nên sửa đổi __dict__ trực tiếp.

Các mô-đun được tích hợp trong trình thông dịch được viết như sau: <module 'sys' (built-in)>. Nếu được tải từ một tệp, chúng được viết là <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>.

Lớp học và phiên bản lớp học

Xem Đối tượng, giá trị và loại và Định nghĩa lớp để biết những điều này.

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ó: func(argument-list).

Thực sự có hai loại đối tượng hàm: hàm dựng sẵn và hàm 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 triển khai khác nhau, do đó có 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 loại: built-in methods (chẳng hạn như append() trong danh sách) và class instance method. Các phương thức tích hợp được mô tả cùng 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: đối tượng bound method (còn gọi là instance method). Khi được gọi, nó sẽ thêm đối số self vào danh sách đối số. Các phương thức liên kết có hai thuộc tính chỉ đọc đặc biệt: m.__self__ là đối tượng mà phương thức đó hoạt động và m.__func__ là hàm thực hiện phương thức đó. Gọi m(arg-1, arg-2, ..., arg-n) hoàn toàn tương đương với gọi m.__func__(m.__self__, arg-1, arg-2, ..., arg-n).

Giống như function objects, các đối tượng phương thức liên kết hỗ trợ nhận các thuộc tính tùy ý. Tuy nhiên, vì các thuộc tính phương thức thực sự được lưu trữ trên đối tượng hàm cơ bản (method.__func__), nên việc thiết lập các thuộc tính 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 thuộc tính trên một phương thức sẽ dẫn đến AttributeError được nâng lên. Để đặt thuộc tính phương thức, bạn cần đặt rõ ràng thuộc tính đó trên đối tượng hàm cơ bản:

>>> lớp C:
... phương thức def (tự):
... vượt qua
...
>>> c = C()
>>> c.method.whoami = 'tên tôi là phương thức' # can chưa được đặt trên phương thức
Traceback (cuộc gọi gần đây nhất):
  Tệp "<stdin>", dòng 1, trong <module>
AttributionError: đối tượng 'phương thức' không có thuộc tính 'whoami'
>>> c.method.__func__.whoami = 'tên tôi là phương thức'
>>> c.method.whoami
'tên tôi là phương pháp'

Xem Phương thức sơ thẩm để biết thêm thông tin.

Đối tượng mã

Các đối tượng mã được quá trình triển khai sử dụng để thể hiện mã Python thực thi "được biên dịch giả", chẳng hạn như phần thân hàm. Chúng khác với các đối tượng hàm vì chúng không chứa tham chiếu đến môi trường thực thi toàn cục của chúng. Các đối tượng mã được hàm compile() tích hợp trả về và có thể được trích xuất từ ​​các đối tượng hàm thông qua thuộc tính __code__ của chúng. Xem thêm mô-đun code.

Việc truy cập __code__ sẽ tạo ra auditing event object.__getattr__ với các đối số obj và "__code__".

Một đối tượng mã có thể được thực thi hoặc đánh giá bằng cách chuyển nó (thay vì chuỗi nguồn) tới các hàm dựng sẵn exec() hoặc eval().

Xem Hệ thống phân cấp loại tiêu chuẩn để biết thêm thông tin.

Loại đối tượng

Đối tượng loại đạ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 hàm type() tích hợp. Không có hoạt động đặc biệt trên các loại. Mô-đun tiêu chuẩn types 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: <class 'int'>.

Đối tượng rỗng

Đố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ó hỗ trợ không có hoạt động đặc biệt. Có chính xác một đối tượng null, được đặt tên là None (tên có sẵn). type(None)() tạo ra cùng một singleton.

Nó được viết là None.

Đối tượng Ellipsis

Đối tượng này thường được sử dụng để chỉ ra rằng một cái gì đó bị bỏ qua. Nó hỗ trợ không có hoạt động đặc biệt. Có chính xác một đối tượng dấu ba chấm, được đặt tên là Ellipsis (tên có sẵn). type(Ellipsis)() tạo ra singleton Ellipsis.

Nó được viết là Ellipsis hoặc ....

Trong cách sử dụng thông thường, ... là đối tượng Ellipsis xuất hiện ở một vài nơi khác nhau, chẳng hạn:

• Trong các chú thích kiểu, chẳng hạn như callable arguments hoặc tuple elements.

• Là phần thân của một hàm thay vì pass statement.

• Trong thư viện của bên thứ ba, chẳng hạn như Numpy's slicing and striding.

Ví dụ, Python cũng sử dụng ba dấu chấm theo những cách không phải là đối tượng Ellipsis:

• ELLIPSIS của Doctest, làm mẫu cho nội dung bị thiếu.

• Lời nhắc Python mặc định của shell interactive khi dữ liệu nhập một phần không đầy đủ.

Cuối cùng, tài liệu Python thường sử dụng ba dấu chấm trong cách sử dụng tiếng Anh thông thường để biểu thị nội dung bị lược bỏ, ngay cả trong các ví dụ mã cũng sử dụng chúng như Ellipsis.

Đối tượng chưa được triển khai

Đối tượng này được trả về từ các 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 kiểu 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 NotImplemented. type(NotImplemented)() tạo phiên bản singleton.

Nó được viết là NotImplemented.

Đố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 stack frame objects, traceback objects và slice.

Thuộc tính đặc biệt

Việc triển khai thêm một số thuộc tính chỉ đọc đặc biệt vào một số loại đối tượng nếu chúng có liên quan. Một số trong số này không được báo cáo bởi chức năng tích hợp dir().

definition.__name__

Tên của lớp, hàm, phương thức, bộ mô tả hoặc phiên bản trình tạo.

definition.__qualname__

qualified name của lớp, hàm, phương thức, bộ mô tả hoặc phiên bản trình tạo.

Added in version 3.3.

definition.__module__

Tên của mô-đun trong đó lớp hoặc hàm được xác định.

definition.__doc__

Chuỗi tài liệu của một lớp hoặc hàm hoặc None nếu không được xác định.

definition.__type_params__

type parameters của các lớp, hàm chung và type aliases. Đối với các lớp và hàm không chung, đây sẽ là một bộ trống.

Added in version 3.12.

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 int và str để giảm thiểu các cuộc tấn công từ chối dịch vụ. Giới hạn only này áp dụng cho các cơ sở số thập phân hoặc không có lũy thừa hai khác. 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 int trong CPython là 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 số nguyên nhị phân hoặc số nguyên nhị phân thành chuỗi trong thời gian tuyến tính, unless cơ số là lũy thừa của 2. Ngay cả các thuật toán nổi tiếng nhất cho cơ số 10 cũng có độ phức tạp dưới bậc hai. Việc chuyển đổi một giá trị lớn chẳng hạn như int('1' * 500_000) có thể mất hơn một giây trên CPU nhanh.

Việc giới hạn kích thước chuyển đổi mang lại 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 có liên quan đến 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 thao tác vượt quá giới hạn, ValueError sẽ được nâng lên:

>>> nhập hệ thống
>>> sys.set_int_max_str_digits(4300) # Illustrative, đây là mặc định.
>>> _ = int('2' * 5432)
Traceback (cuộc gọi gần đây nhất):
...
ValueError: Vượt quá giới hạn (4300 chữ số) để chuyển đổi chuỗi số nguyên: giá trị có 5432 chữ số; sử dụng sys.set_int_max_str_digits() để tăng giới hạn
>>> i = int('2' * 4300)
>>> len(str(i))
4300
>>> i_bình phương = i*i
>>> len(str(i_squared))
Traceback (cuộc gọi gần đây nhất):
...
ValueError: Vượt quá giới hạn (4300 chữ số) để chuyển đổi chuỗi số nguyên; sử dụng sys.set_int_max_str_digits() để tăng giới hạn
>>> len(hex(i_squared))
7144
>>> khẳng định int(hex(i_squared), base=16) == i*i # Hexadecimal là không giới hạn.

Giới hạn mặc định là 4300 chữ số như được cung cấp trong sys.int_info.default_max_str_digits. Giới hạn thấp nhất có thể được cấu hình là 640 chữ số như được cung cấp trong sys.int_info.str_digits_check_threshold.

Xác minh:

>>> nhập hệ thống
>>> khẳng định sys.int_info.default_max_str_digits == 4300, sys.int_info
>>> khẳng định sys.int_info.str_digits_check_threshold == 640, sys.int_info
>>> tin nhắn = int('578966293710682886880994035146873798396722250538762761564'
... '9252925514383915483333812743580549779436104706260696366600'
... '571186405732').to_bytes(53, 'lớn')
...

Added in version 3.11.

API bị ảnh hưởng

Giới hạn chỉ áp dụng cho các chuyển đổi có thể chậm giữa int và str hoặc bytes:

• int(string) với cơ sở mặc định là 10.

• int(string, base) cho tất cả các cơ số không phải là lũy thừa của 2.

• str(integer).

• repr(integer).

• bất kỳ chuyển đổi chuỗi nào khác sang cơ sở 10, ví dụ: f"{integer}", "{}".format(integer) hoặc b"%d" % integer.

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:

• int(string, base) với cơ sở 2, 4, 8, 16 hoặc 32.

• int.from_bytes() và int.to_bytes().

• hex(), oct(), bin().

• Đặc tả định dạng ngôn ngữ nhỏ cho số hex, bát phân và nhị phân.

• str đến float.

• str đến decimal.Decimal.

Đị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 trình thông dịch để định cấu hình giới hạn:

• PYTHONINTMAXSTRDIGITS, ví dụ: PYTHONINTMAXSTRDIGITS=640 python3 để đặt giới hạn thành 640 hoặc PYTHONINTMAXSTRDIGITS=0 python3 để tắt giới hạn.

• -X int_max_str_digits, ví dụ: python3 -X int_max_str_digits=640

• sys.flags.int_max_str_digits chứa giá trị của PYTHONINTMAXSTRDIGITS hoặc -X int_max_str_digits. Nếu cả tùy chọn env var và -X đều được đặt, tùy chọn -X sẽ được ưu tiên. Giá trị -1 cho biết cả hai đều chưa được đặt, do đó giá trị sys.int_info.default_max_str_digits đã đượ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 sys sau:

• sys.get_int_max_str_digits() và sys.set_int_max_str_digits() là công cụ getter và setter cho giới hạn trên toàn trình thông dịch. Phiên dịch viên phụ có giới hạn riêng của họ.

Thông tin về mặc định và tối thiểu có thể được tìm thấy trong sys.int_info:

• sys.int_info.default_max_str_digits là giới hạn mặc định được biên dịch sẵn.

• sys.int_info.str_digits_check_threshold là giá trị giới hạn được chấp nhận thấp nhất (khác với 0 sẽ vô hiệu hóa giới hạn này).

Added in version 3.11.

Cảnh báo

Việc đặt giới hạn thấp can sẽ dẫn đến nhiều vấn đề. Mặc dù hiếm gặp nhưng tồn tại mã 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 chữ 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à lúc khởi động hoặc lúc nhập hoặc thậm chí tại thời điểm cài đặt - bất cứ khi nào mã .pyc cập nhật chưa tồn tại. Một cách giải quyết 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 0x vì nó không có giới hạn.

Kiểm tra kỹ ứng dụng của bạn 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 gắn cờ để giới hạn đó được á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 .py thành tệp .pyc.

Cấu hình đề xuất

sys.int_info.default_max_str_digits mặc định được cho là 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 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 ở các phiên bản trước 3.12.

Ví dụ:

>>> nhập hệ thống
>>> if hasattr(sys, "set_int_max_str_digits"):
... giới hạn trên = 68000
... giới hạn dưới = 4004
... current_limit = sys.get_int_max_str_digits()
... nếu current_limit == 0 hoặc current_limit > giới hạn trên:
... sys.set_int_max_str_digits(upper_bound)
... elif current_limit < low_bound:
... sys.set_int_max_str_digits(low_bound)

Nếu bạn cần tắt hoàn toàn, hãy đặt nó thành 0.

Chú thích cuối trang

[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, 2] được coi là bằng [1.0, 2.0] 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)

Ký tự được viết vỏ là những ký tự có đặc tính danh mục chung là một trong các "Lu" (Chữ cái, chữ hoa), "Ll" (Chữ cái, chữ thường) hoặc "Lt" (Chữ cái, chữ hoa).

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