Table of Contents
- What is pow[ ] Function?
- Implementation Case
- pow[ ] Function in Python
- Output
- Python pow[ ] Function with Modulus
- Output
- Python pow[ ] Function using Math Module
- Output
- FAQs
- What data type does the pow function return in Python?
- Can pow function take 3 arguments?
- Conclusion
What is pow[ ] Function?
The Pow[] function in Python is used to authoritatively calculate the power of a number. It takes two arguments, x and y, representing the X and Y components of a pow_func object, respectively. The Pow[] function then returns the value of pow[x, y]
Implementation Case
pow[ ] Function in Python
The Pow[] function is a mathematical function that calculates the power of a number and can be used to calculate the exponent of a number, which helps solve equations or perform complex calculations
The Pow[] function takes two arguments. the first argument is the base, and the second argument is the exponent
print[pow[3, 3]]
print[pow[-4, 4]] Output
Python pow[ ] Function with Modulus
The pow[] function can be used to calculate the power of a number. The modulus operator allows you to find the remainder after dividing two numbers. This is an important operation when working with complex mathematical problems, as it helps solve equations and express relationships between variables. The pow[] function takes two arguments. the first is the base value, and the second is the exponent. If neither argument is specified, then 10 will be assumed as both values are powers of 2
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Output
Python pow[ ] Function using Math Module
You can use the math module to calculate the pow[] function in Python. This module contains functions that are used for mathematical operations. To access this module, you need to enter import math at the beginning of your script. Once the math module is imported, you can begin using its functions. The Pow[] function takes two arguments and returns a number according to its parameters
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Output
Tìm hiểu thêm về các chức năng tích hợp sẵn của hàm pow[] trong Python, hãy truy cập bài viết, Triển khai sức mạnh trong Python bằng các phương pháp khác nhau
FAQs
What data type does the pow function return in Python?
Nếu một số nguyên được truyền làm đối số cho phương thức pow[], nó sẽ trả về một số float;
Can pow function take 3 arguments?
Giá trị cơ sở được nâng lên một công suất cụ thể bằng cách sử dụng phương thức pow[], phương thức này có ba tham số. số – giá trị ban đầu. Giá trị số mũ làm tăng số gọi là lũy thừa. number^power % modulus phương thức trả về phần còn lại khi kết quả của một số bị tạm dừng được chia cho một lũy thừa
Conclusion
Trong blog này, chúng tôi đã giải thích hàm Python Pow[] bằng các ví dụ. Tuy nhiên, nó không phải là đơn giản. Chức năng này có thể được sử dụng trong các tính toán khác nhau để có được kết quả chính xác hơn. Hàm Pow[] là một trong những phần quan trọng nhất trong bộ công cụ của bất kỳ lập trình viên nào. Biết cách sử dụng nó có thể giúp bạn tự tin hơn vào kỹ năng viết mã Python của mình. Mã hóa vui vẻ
Trình thông dịch Python có một số hàm và kiểu được tích hợp sẵn luôn sẵn dùng. Chúng được liệt kê ở đây theo thứ tự bảng chữ cái
Chức năng tích hợp sẵn
A
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']4
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']5
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']6
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']7
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']8
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']9
B
class C: @classmethod def f[cls, arg1, arg2]: ...0
class C: @classmethod def f[cls, arg1, arg2]: ...1
class C: @classmethod def f[cls, arg1, arg2]: ...2
class C: @classmethod def f[cls, arg1, arg2]: ...3
class C: @classmethod def f[cls, arg1, arg2]: ...4
C
class C: @classmethod def f[cls, arg1, arg2]: ...5
class C: @classmethod def f[cls, arg1, arg2]: ...6
class C: @classmethod def f[cls, arg1, arg2]: ...7
class C: @classmethod def f[cls, arg1, arg2]: ...8
class C: @classmethod def f[cls, arg1, arg2]: ...9
D
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] E
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] F
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] G
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] H
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] I
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']90
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']91
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']92
L
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']94
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95
M
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']96
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']98
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99
N
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']90
O
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']91
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']92
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']94
P
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']96
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97
R
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']98
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']90
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']91
S
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']92
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']94
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']96
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']98
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99
T
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']900
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']901
V
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']902
Z
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']903
_
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']904abs[x] ¶
Return the absolute value of a number. The argument may be an integer, a floating point number, or an object implementing
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']905. If the argument is a complex number, its magnitude is returnedaiter[async_iterable] ¶
Trả về một trình lặp không đồng bộ cho một có thể lặp không đồng bộ . Equivalent to calling
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']906.
Ghi chú. Không giống như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']92,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']5 không có biến thể 2 đối số
Mới trong phiên bản 3. 10
tất cả[có thể lặp lại] ¶Trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu tất cả các phần tử của iterable là đúng [hoặc nếu iterable trống]. Tương đương với
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']9awaitable next[async_iterator]¶awaitable anext[async_iterator, default]
Khi được chờ đợi, hãy trả về mục tiếp theo từ trình lặp không đồng bộ đã cho hoặc mặc định nếu được cung cấp và trình lặp đã hết.
Đây là biến thể không đồng bộ của nội dung dựng sẵn
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']90 và hoạt động tương tự
Điều này gọi phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']911 của async_iterator, trả về awaitable . Đang chờ điều này trả về giá trị tiếp theo của trình vòng lặp. Nếu giá trị mặc định được đưa ra, nó sẽ được trả về nếu bộ vòng lặp đã cạn kiệt, nếu không, thì
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']912 sẽ được nâng lên.
Mới trong phiên bản 3. 10
bất kỳ[có thể lặp lại] ¶Trả lại
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu bất kỳ phần tử nào của iterable là true. Nếu iterable trống, hãy trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914. Tương đương với
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']9ascii[đối tượng] ¶
Là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99, trả về một chuỗi chứa biểu diễn có thể in được của một đối tượng, nhưng thoát các ký tự không phải ASCII trong chuỗi được trả về bởi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99 bằng cách sử dụng các ký tự thoát
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']917,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']918 hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']919. Điều này tạo ra một chuỗi tương tự như chuỗi được trả về bởi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99 trong Python 2bin[x] ¶
Chuyển đổi một số nguyên thành một chuỗi nhị phân có tiền tố là “0b”. Kết quả là một biểu thức Python hợp lệ. Nếu x không phải là một đối tượng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 của Python, thì nó phải xác định một phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922 trả về một số nguyên. Vài ví dụ
class C: @classmethod def f[cls, arg1, arg2]: ...4
Nếu muốn hoặc không muốn tiền tố “0b”, bạn có thể sử dụng một trong hai cách sau
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
Xem thêm
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Trả về giá trị Boolean, i. e. một trong số
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914. x được chuyển đổi bằng cách sử dụng quy trình kiểm tra độ chính xác tiêu chuẩn. Nếu x là sai hoặc bị bỏ qua, điều này trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914; . Lớp
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']928 là một lớp con của
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 [xem Kiểu số — int, float, complex ]. Nó không thể được phân loại thêm. Phiên bản duy nhất của nó là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914 và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 [xem Giá trị Boolean ].
Đã thay đổi trong phiên bản 3. 7. x hiện là tham số chỉ vị trí.
điểm dừng[*args , **kws]¶Chức năng này đưa bạn vào trình gỡ lỗi tại trang cuộc gọi. Cụ thể, nó gọi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']932, đi thẳng qua
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']933 và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']934. Theo mặc định, ________ 6932 gọi ________ 6936 dự kiến không có đối số. Trong trường hợp này, đây hoàn toàn là một chức năng tiện lợi nên bạn không cần phải nhập rõ ràng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']937 hoặc nhập nhiều mã để vào trình gỡ lỗi. Tuy nhiên,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']932 có thể được đặt thành một số chức năng khác và
class C: @classmethod def f[cls, arg1, arg2]: ...2 sẽ tự động gọi chức năng đó, cho phép bạn chuyển sang trình gỡ lỗi tùy chọn. Nếu không truy cập được
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']932, chức năng này sẽ tăng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']941
Tăng sự kiện kiểm tra
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']942 với đối số
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']943.
Mới trong phiên bản 3. 7
lớp bytearray[nguồn=b'']class bytearray[source, encoding]class bytearray[source, encoding, errors]Trả về một mảng byte mới. Lớp >>> format[14, '#b'], format[14, 'b']
['0b1110', '1110']
>>> f'{14:#b}', f'{14:b}'
['0b1110', '1110']
944 là một dãy số nguyên có thể thay đổi trong phạm vi 0 >> format[14, '#b'], format[14, 'b']
['0b1110', '1110']
>>> f'{14:#b}', f'{14:b}'
['0b1110', '1110']
945 có, xem >> format[14, '#b'], format[14, 'b']
['0b1110', '1110']
>>> f'{14:#b}', f'{14:b}'
['0b1110', '1110']
945 type has, see Bytes and Bytearray Operations.
Tham số nguồn tùy chọn có thể được sử dụng để khởi tạo mảng theo một số cách khác nhau
Nếu đó là một chuỗi, bạn cũng phải cung cấp các tham số mã hóa [và tùy chọn, lỗi];
Nếu là số nguyên thì mảng sẽ có kích thước đó và sẽ được khởi tạo với byte rỗng
Nếu nó là một đối tượng phù hợp với giao diện bộ đệm , bộ đệm chỉ đọc của đối tượng sẽ được sử dụng để khởi tạo mảng byte.
Nếu nó là một iterable, nó phải là một iterable của các số nguyên trong phạm vi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
948, được sử dụng làm nội dung ban đầu của mảng
Không có đối số, một mảng có kích thước 0 được tạo
Xem thêm Các loại chuỗi nhị phân — byte, bytearray, memoryview và Đối tượng bytearray.
lớp byte[nguồn=b'']class bytes[source, encoding]class bytes[source, encoding, errors]Trả về một đối tượng "byte" mới là một chuỗi số nguyên bất biến trong phạm vi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']948.
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']945 là một phiên bản không thay đổi của
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']944 – nó có cùng các phương thức không thay đổi và cùng hành vi lập chỉ mục và cắt
Theo đó, các đối số hàm tạo được hiểu là đối với
class C: @classmethod def f[cls, arg1, arg2]: ...3
Đối tượng byte cũng có thể được tạo bằng chữ, xem Chuỗi và byte chữ .
Xem thêm Các loại chuỗi nhị phân — byte, bytearray, memoryview , Đối tượng byte, and Bytes and Bytearray Operations.
có thể gọi được[đối tượng] ¶Trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu đối số đối tượng xuất hiện có thể gọi được,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914 nếu không. Nếu điều này trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909, vẫn có khả năng cuộc gọi không thành công, nhưng nếu nó là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914, đối tượng gọi sẽ không bao giờ thành công. Lưu ý rằng các lớp có thể gọi được [gọi một lớp trả về một thể hiện mới];
Mới trong phiên bản 3. 2. Hàm này lần đầu tiên bị xóa trong Python 3. 0 và sau đó được đưa trở lại Python 3. 2.
chr[i] ¶Trả về chuỗi đại diện cho một ký tự có điểm mã Unicode là số nguyên i. Ví dụ:
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']958 trả về chuỗi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']959, trong khi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']960 trả về chuỗi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']961. Đây là nghịch đảo của
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']94
Phạm vi hợp lệ cho đối số là từ 0 đến 1.114.111 [0x10FFFF trong cơ số 16].
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']963 sẽ tăng nếu tôi nằm ngoài phạm vi đó@phương thức lớp ¶
Chuyển đổi một phương thức thành một phương thức lớp
Một phương thức lớp nhận lớp dưới dạng đối số đầu tiên ngầm định, giống như một phương thức thể hiện nhận thể hiện. Để khai báo một phương thức lớp, hãy sử dụng thành ngữ này
class C: @classmethod def f[cls, arg1, arg2]: ...
Biểu mẫu
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']964 là một hàm trang trí – xem Định nghĩa hàm for details.
Một phương thức lớp có thể được gọi trên lớp [chẳng hạn như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']965] hoặc trên một thể hiện [chẳng hạn như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']966]. Thể hiện bị bỏ qua ngoại trừ lớp của nó. Nếu một phương thức lớp được gọi cho một lớp dẫn xuất, thì đối tượng lớp dẫn xuất được truyền dưới dạng đối số đầu tiên ngụ ý
Các phương thức của lớp khác với các phương thức tĩnh của C++ hoặc Java. Nếu bạn muốn những thứ đó, hãy xem
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']96 trong phần này. Để biết thêm thông tin về các phương thức của lớp, hãy xem Hệ thống phân cấp loại tiêu chuẩn .
Đã thay đổi trong phiên bản 3. 9. Các phương thức của lớp hiện có thể bọc các mô tả khác, chẳng hạn như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97.
Đã thay đổi trong phiên bản 3. 10. Các phương thức của lớp hiện kế thừa các thuộc tính của phương thức [
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']969,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']970,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']971,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']972 và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']973] và có thuộc tính mới
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']974.
Đã thay đổi trong phiên bản 3. 11. Các phương thức lớp không còn có thể bọc các mô tả khác, chẳng hạn như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97. biên dịch[nguồn , tên tệp, mode, flags=0, dont_inherit=False, optimize=- 1]¶
Biên dịch nguồn thành mã hoặc đối tượng AST. Các đối tượng mã có thể được thực thi bởi
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']978 để biết thông tin về cách làm việc với các đối tượng AST
Đối số tên tệp sẽ cung cấp tệp mà mã được đọc từ đó;
Đối số chế độ chỉ định loại mã nào phải được biên dịch;
Các cờ đối số tùy chọn và dont_inherit kiểm soát tùy chọn trình biên dịch nào sẽ được kích hoạt và tính năng nào trong tương lai< . Nếu không có [hoặc cả hai đều bằng 0], mã được biên dịch với cùng các cờ ảnh hưởng đến mã đang gọi class C:
@classmethod
def f[cls, arg1, arg2]: ...
8. Nếu đối số flags được đưa ra và không_inherit không [hoặc bằng 0] thì các tùy chọn trình biên dịch và các câu lệnh trong tương lai được chỉ định bởi đối số flags sẽ được sử dụng ngoài các tùy chọn sẽ được sử dụng. Nếu don_inherit là một số nguyên khác 0 thì đối số flags chính là nó – các cờ [các tính năng trong tương lai và tùy chọn trình biên dịch] trong mã xung quanh sẽ bị bỏ qua. should be allowed. If neither is present [or both are zero] the code is compiled with the same flags that affect the code that is calling
class C: @classmethod def f[cls, arg1, arg2]: ...8. If the flags argument is given and dont_inherit is not [or is zero] then the compiler options and the future statements specified by the flags argument are used in addition to those that would be used anyway. If dont_inherit is a non-zero integer then the flags argument is it – the flags [future features and compiler options] in the surrounding code are ignored.
Các tùy chọn trình biên dịch và các câu lệnh trong tương lai được chỉ định bởi các bit có thể được OR theo bit cùng nhau để chỉ định nhiều tùy chọn. Trường bit được yêu cầu để chỉ định một tính năng nhất định trong tương lai có thể được tìm thấy dưới dạng thuộc tính
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']985 trên phiên bản
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']986 trong mô-đun
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']987. Cờ trình biên dịch có thể được tìm thấy trong mô-đun
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']978, với tiền tố
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']989.
Đối số tối ưu hóa chỉ định mức độ tối ưu hóa của trình biên dịch; . Các mức rõ ràng là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']992 [không tối ưu hóa;
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']993 là đúng],
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']994 [các xác nhận bị xóa,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']993 là sai] hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']996 [các chuỗi tài liệu cũng bị xóa]
Hàm này tăng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']997 nếu nguồn đã biên dịch không hợp lệ và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']963 nếu nguồn chứa byte rỗng
Nếu bạn muốn phân tích mã Python thành biểu diễn AST của nó, hãy xem
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']999
Tăng sự kiện kiểm tra
class C: @classmethod def f[cls, arg1, arg2]: ...400 với các đối số
class C: @classmethod def f[cls, arg1, arg2]: ...401 và
class C: @classmethod def f[cls, arg1, arg2]: ...402. Sự kiện này cũng có thể được nâng lên bằng cách tổng hợp ngầm.
Ghi chú
Khi biên dịch một chuỗi có mã nhiều dòng ở chế độ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']982 hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']981, đầu vào phải được kết thúc bằng ít nhất một ký tự xuống dòng. Điều này là để tạo điều kiện phát hiện các báo cáo không đầy đủ và đầy đủ trong mô-đun
class C: @classmethod def f[cls, arg1, arg2]: ...405
Cảnh báo
Có thể làm hỏng trình thông dịch Python với chuỗi đủ lớn/phức tạp khi biên dịch thành đối tượng AST do giới hạn độ sâu ngăn xếp trong trình biên dịch AST của Python
Đã thay đổi trong phiên bản 3. 2. Được phép sử dụng dòng mới của Windows và Mac. Ngoài ra, đầu vào ở chế độ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']980 không phải kết thúc bằng một dòng mới nữa. Đã thêm tham số tối ưu hóa.
Đã thay đổi trong phiên bản 3. 5. Trước đây,
class C: @classmethod def f[cls, arg1, arg2]: ...407 đã xuất hiện khi gặp phải byte rỗng trong nguồn.
Mới trong phiên bản 3. 8.
class C: @classmethod def f[cls, arg1, arg2]: ...408 giờ đây có thể được chuyển vào các cờ để kích hoạt hỗ trợ cho
class C: @classmethod def f[cls, arg1, arg2]: ...409,
class C: @classmethod def f[cls, arg1, arg2]: ...410 và
class C: @classmethod def f[cls, arg1, arg2]: ...411 cấp cao nhất. lớp phức tạp[thực=0, imag=0]¶class complex[string]
Trả về một số phức với giá trị thực + hình ảnh*1j hoặc chuyển đổi một chuỗi hoặc số thành một số phức. Nếu tham số đầu tiên là một chuỗi, nó sẽ được hiểu là một số phức và hàm phải được gọi mà không có tham số thứ hai. Tham số thứ hai không bao giờ có thể là một chuỗi. Mỗi đối số có thể là bất kỳ loại số nào [kể cả phức tạp]. Nếu hình ảnh bị bỏ qua, nó sẽ mặc định bằng 0 và hàm tạo đóng vai trò chuyển đổi số như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 và
class C: @classmethod def f[cls, arg1, arg2]: ...413. Nếu cả hai đối số bị bỏ qua, trả về
class C: @classmethod def f[cls, arg1, arg2]: ...414
Đối với một đối tượng Python chung
class C: @classmethod def f[cls, arg1, arg2]: ...415,
class C: @classmethod def f[cls, arg1, arg2]: ...416 ủy quyền cho
class C: @classmethod def f[cls, arg1, arg2]: ...417. Nếu
class C: @classmethod def f[cls, arg1, arg2]: ...418 không được xác định thì nó sẽ quay trở lại
class C: @classmethod def f[cls, arg1, arg2]: ...419. Nếu
class C: @classmethod def f[cls, arg1, arg2]: ...419 không được xác định thì nó sẽ quay trở lại
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922
Ghi chú
Khi chuyển đổi từ một chuỗi, chuỗi không được chứa khoảng trắng xung quanh toán tử trung tâm
class C: @classmethod def f[cls, arg1, arg2]: ...422 hoặc
class C: @classmethod def f[cls, arg1, arg2]: ...423. Ví dụ:
class C: @classmethod def f[cls, arg1, arg2]: ...424 cũng được, nhưng
class C: @classmethod def f[cls, arg1, arg2]: ...425 tăng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']963
Kiểu phức hợp được mô tả trong Kiểu số — int, float, complex .
Đã thay đổi trong phiên bản 3. 6. Cho phép nhóm các chữ số có dấu gạch dưới như trong mã chữ.
Đã thay đổi trong phiên bản 3. 8. Trở về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922 nếu
class C: @classmethod def f[cls, arg1, arg2]: ...418 và
class C: @classmethod def f[cls, arg1, arg2]: ...419 không được xác định. delattr[đối tượng , tên]¶
Đây là họ hàng của
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93. Các đối số là một đối tượng và một chuỗi. Chuỗi phải là tên của một trong các thuộc tính của đối tượng. Hàm xóa thuộc tính được đặt tên, miễn là đối tượng cho phép. Ví dụ,
class C: @classmethod def f[cls, arg1, arg2]: ...431 tương đương với
class C: @classmethod def f[cls, arg1, arg2]: ...432. tên không cần phải là mã định danh Python [xem
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93]class dict[**kwarg]class dict[mapping, **kwarg]class dict[iterable, **kwarg]
Tạo từ điển mới. Đối tượng
class C: @classmethod def f[cls, arg1, arg2]: ...434 là lớp từ điển. Xem
class C: @classmethod def f[cls, arg1, arg2]: ...434 và Các loại ánh xạ — dict để biết tài liệu về lớp này.
Đối với các vùng chứa khác, hãy xem các lớp
class C: @classmethod def f[cls, arg1, arg2]: ...436,
class C: @classmethod def f[cls, arg1, arg2]: ...437 và
class C: @classmethod def f[cls, arg1, arg2]: ...438 tích hợp, cũng như mô-đun
class C: @classmethod def f[cls, arg1, arg2]: ...439dir[] ¶ dir[object]
Không có đối số, trả về danh sách tên trong phạm vi cục bộ hiện tại. Với một đối số, cố gắng trả về danh sách các thuộc tính hợp lệ cho đối tượng đó
Nếu đối tượng có một phương thức tên là
class C: @classmethod def f[cls, arg1, arg2]: ...440, phương thức này sẽ được gọi và phải trả về danh sách các thuộc tính. Điều này cho phép các đối tượng triển khai hàm
class C: @classmethod def f[cls, arg1, arg2]: ...441 hoặc
class C: @classmethod def f[cls, arg1, arg2]: ...442 tùy chỉnh để tùy chỉnh cách thức
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Nếu đối tượng không cung cấp
class C: @classmethod def f[cls, arg1, arg2]: ...440, hàm sẽ cố gắng hết sức để thu thập thông tin từ thuộc tính
class C: @classmethod def f[cls, arg1, arg2]: ...445 của đối tượng, nếu được xác định và từ đối tượng loại của nó. Danh sách kết quả không nhất thiết phải đầy đủ và có thể không chính xác khi đối tượng có một
class C: @classmethod def f[cls, arg1, arg2]: ...441 tùy chỉnh
Cơ chế
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Nếu đối tượng là một đối tượng mô-đun, danh sách chứa tên của các thuộc tính của mô-đun
Nếu đối tượng là một đối tượng kiểu hoặc lớp, thì danh sách chứa tên của các thuộc tính của nó và đệ quy các thuộc tính của các cơ sở của nó
Mặt khác, danh sách chứa các tên thuộc tính của đối tượng, tên của các thuộc tính của lớp đối tượng và đệ quy các thuộc tính của các lớp cơ sở của lớp đối tượng.
Danh sách kết quả được sắp xếp theo thứ tự bảng chữ cái. Ví dụ
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Ghi chú
Bởi vì
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Lấy hai số [không phức tạp] làm đối số và trả về một cặp số bao gồm thương và số dư của chúng khi sử dụng phép chia số nguyên. Với các loại toán hạng hỗn hợp, áp dụng các quy tắc cho toán tử số học nhị phân. Đối với số nguyên, kết quả giống như
class C: @classmethod def f[cls, arg1, arg2]: ...449. Đối với số dấu phẩy động, kết quả là
class C: @classmethod def f[cls, arg1, arg2]: ...450, trong đó q thường là
class C: @classmethod def f[cls, arg1, arg2]: ...451 nhưng có thể nhỏ hơn 1. Trong mọi trường hợp,
class C: @classmethod def f[cls, arg1, arg2]: ...452 rất gần với a, nếu
class C: @classmethod def f[cls, arg1, arg2]: ...453 khác 0 thì nó có cùng dấu với b, và
class C: @classmethod def f[cls, arg1, arg2]: ...454liệt kê[có thể lặp lại , bắt đầu=0]¶
Trả về một đối tượng liệt kê. iterable phải là một trình tự, một iterator hoặc một số đối tượng khác hỗ trợ phép lặp. Phương thức
class C: @classmethod def f[cls, arg1, arg2]: ...455 của trình vòng lặp được trả về bởi
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Tương đương với
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']9eval[biểu thức , toàn cầu=None, locals=None]¶
Các đối số là một chuỗi và toàn cục và cục bộ tùy chọn. Nếu được cung cấp, toàn cầu phải là một từ điển. Nếu được cung cấp, người dân địa phương có thể là bất kỳ đối tượng ánh xạ nào
Đối số biểu thức được phân tích cú pháp và đánh giá dưới dạng một biểu thức Python [về mặt kỹ thuật, một danh sách điều kiện] bằng cách sử dụng từ điển toàn cầu và cục bộ dưới dạng không gian tên toàn cầu và cục bộ. Nếu có từ điển toàn cục và không chứa giá trị cho khóa
class C: @classmethod def f[cls, arg1, arg2]: ...457, thì một tham chiếu đến từ điển của mô-đun tích hợp sẵn
class C: @classmethod def f[cls, arg1, arg2]: ...458 sẽ được chèn vào bên dưới khóa đó trước khi biểu thức được phân tích cú pháp. Bằng cách đó, bạn có thể kiểm soát nội trang nào có sẵn cho mã được thực thi bằng cách chèn từ điển
class C: @classmethod def f[cls, arg1, arg2]: ...457 của riêng bạn vào toàn cầu trước khi chuyển nó tới
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Giá trị trả về là kết quả của biểu thức được đánh giá. Lỗi cú pháp được báo cáo là ngoại lệ. Ví dụ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']9
Hàm này cũng có thể được sử dụng để thực thi các đối tượng mã tùy ý [chẳng hạn như các đối tượng được tạo bởi
class C: @classmethod def f[cls, arg1, arg2]: ...8]. Trong trường hợp này, hãy chuyển một đối tượng mã thay vì một chuỗi. Nếu đối tượng mã đã được biên dịch với
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']980 làm đối số chế độ, giá trị trả về của
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983
gợi ý. thực thi động các câu lệnh được hỗ trợ bởi hàm
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95 lần lượt trả về từ điển cục bộ và toàn cầu hiện tại, có thể hữu ích khi chuyển qua để sử dụng bởi
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Nếu nguồn đã cho là một chuỗi, thì các dấu cách và tab ở đầu và cuối sẽ bị loại bỏ
Xem
class C: @classmethod def f[cls, arg1, arg2]: ...471 để biết một hàm có thể đánh giá các chuỗi một cách an toàn bằng các biểu thức chỉ chứa các ký tự
Tăng sự kiện kiểm tra
class C: @classmethod def f[cls, arg1, arg2]: ...472 với đối tượng mã làm đối số. Các sự kiện biên dịch mã cũng có thể được nâng lên. exec[đối tượng , toàn cầu=None, locals=None, /, *, closure=None]¶
Hàm này hỗ trợ thực thi động mã Python. đối tượng phải là một chuỗi hoặc một đối tượng mã. Nếu đó là một chuỗi, thì chuỗi đó được phân tích thành một tập hợp các câu lệnh Python, sau đó được thực thi [trừ khi xảy ra lỗi cú pháp]. 1 Nếu nó là một đối tượng mã, nó được thực thi đơn giản. Trong mọi trường hợp, mã được thực thi phải hợp lệ dưới dạng đầu vào tệp [xem phần Đầu vào tệp trong Hướng dẫn tham khảo]. Xin lưu ý rằng các câu lệnh
class C: @classmethod def f[cls, arg1, arg2]: ...473,
class C: @classmethod def f[cls, arg1, arg2]: ...474 và
class C: @classmethod def f[cls, arg1, arg2]: ...475 không được sử dụng bên ngoài các định nghĩa hàm ngay cả trong ngữ cảnh của mã được truyền cho hàm
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983.
Trong mọi trường hợp, nếu các phần tùy chọn bị bỏ qua, mã được thực thi trong phạm vi hiện tại. Nếu chỉ toàn cầu được cung cấp, nó phải là một từ điển [và không phải là một lớp con của từ điển], sẽ được sử dụng cho cả biến toàn cục và biến cục bộ. Nếu toàn cầu và cục bộ được cung cấp, chúng được sử dụng cho các biến toàn cầu và cục bộ tương ứng. Nếu được cung cấp, người dân địa phương có thể là bất kỳ đối tượng ánh xạ nào. Hãy nhớ rằng ở cấp độ mô-đun, toàn cầu và cục bộ là cùng một từ điển. Nếu exec lấy hai đối tượng riêng biệt là toàn cầu và cục bộ, mã sẽ được thực thi như thể nó được nhúng trong một định nghĩa lớp
Nếu từ điển toàn cục không chứa giá trị cho khóa
class C: @classmethod def f[cls, arg1, arg2]: ...457, tham chiếu đến từ điển của mô-đun tích hợp sẵn
class C: @classmethod def f[cls, arg1, arg2]: ...458 sẽ được chèn vào bên dưới khóa đó. Bằng cách đó, bạn có thể kiểm soát nội trang nào có sẵn cho mã được thực thi bằng cách chèn từ điển
class C: @classmethod def f[cls, arg1, arg2]: ...457 của riêng bạn vào toàn cầu trước khi chuyển nó tới
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Đối số đóng chỉ định một đóng – một bộ các ô. Nó chỉ hợp lệ khi đối tượng là một đối tượng mã có chứa các biến tự do. Độ dài của bộ dữ liệu phải khớp chính xác với số lượng biến miễn phí được tham chiếu bởi đối tượng mã
Tăng sự kiện kiểm tra
class C: @classmethod def f[cls, arg1, arg2]: ...472 với đối tượng mã làm đối số. Các sự kiện biên dịch mã cũng có thể được nâng lên.
Ghi chú
Các hàm tích hợp sẵn
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95 lần lượt trả về từ điển cục bộ và toàn cầu hiện tại, có thể hữu ích khi chuyển xung quanh để sử dụng làm đối số thứ hai và thứ ba cho
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Ghi chú
Các địa phương mặc định hoạt động như được mô tả cho chức năng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95 bên dưới. không nên sửa đổi từ điển địa phương mặc định. Vượt qua một từ điển địa phương rõ ràng nếu bạn cần xem tác động của mã đối với người dân địa phương sau khi hàm
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Đã thay đổi trong phiên bản 3. 11. Đã thêm tham số đóng cửa.
bộ lọc[chức năng , có thể lặp lại]¶Xây dựng một iterator từ các phần tử iterable mà hàm trả về true. iterable có thể là một chuỗi, một vùng chứa hỗ trợ phép lặp hoặc một trình lặp. Nếu hàm là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983, thì hàm nhận dạng được giả định, nghĩa là tất cả các phần tử của iterable sai sẽ bị xóa
Lưu ý rằng
class C: @classmethod def f[cls, arg1, arg2]: ...489 tương đương với biểu thức trình tạo
class C: @classmethod def f[cls, arg1, arg2]: ...490 nếu chức năng không phải là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983 và
class C: @classmethod def f[cls, arg1, arg2]: ...492 nếu chức năng là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983
Xem
class C: @classmethod def f[cls, arg1, arg2]: ...494 để biết hàm bổ sung trả về các phần tử của iterable mà hàm trả về falselớp phao[x=0.0] ¶
Trả về một số dấu phẩy động được tạo từ một số hoặc chuỗi x
Nếu đối số là một chuỗi, thì đối số đó phải chứa số thập phân, tùy chọn đứng trước dấu và được nhúng tùy chọn trong khoảng trắng. Dấu hiệu tùy chọn có thể là
class C: @classmethod def f[cls, arg1, arg2]: ...495 hoặc
class C: @classmethod def f[cls, arg1, arg2]: ...496; . Đối số cũng có thể là một chuỗi đại diện cho một NaN [không phải là số] hoặc vô cực dương hoặc âm. Chính xác hơn, đầu vào phải tuân theo quy tắc sản xuất
class C: @classmethod def f[cls, arg1, arg2]: ...498 trong ngữ pháp sau, sau khi các ký tự khoảng trắng ở đầu và cuối bị xóa
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']9
Ở đây
class C: @classmethod def f[cls, arg1, arg2]: ...499 là một chữ số thập phân Unicode [ký tự trong danh mục chung Unicode
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']00]. Trường hợp không đáng kể, vì vậy, ví dụ: “inf”, “Inf”, “INFINITY” và “iNfINity” đều là cách viết chấp nhận được cho vô cực dương
Mặt khác, nếu đối số là một số nguyên hoặc số dấu phẩy động, thì một số dấu phẩy động có cùng giá trị [trong phạm vi độ chính xác của 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 một float Python, một
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']01 sẽ được nâng lên
Đối với một đối tượng Python chung
class C: @classmethod def f[cls, arg1, arg2]: ...415,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']03 ủy quyền cho
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']04. Nếu
class C: @classmethod def f[cls, arg1, arg2]: ...419 không được xác định thì nó sẽ quay trở lại
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922
Nếu không có đối số nào được đưa ra, thì trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']07
ví dụ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']90
Kiểu float được mô tả trong Kiểu số — int, float, complex .
Đã thay đổi trong phiên bản 3. 6. Cho phép nhóm các chữ số có dấu gạch dưới như trong mã chữ.
Đã thay đổi trong phiên bản 3. 7. x hiện là tham số chỉ vị trí.
Đã thay đổi trong phiên bản 3. 8. Trở về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922 nếu không xác định được
class C: @classmethod def f[cls, arg1, arg2]: ...419. định dạng[giá trị , format_spec='']¶
Chuyển đổi giá trị thành biểu diễn “được định dạng”, như được kiểm soát bởi format_spec. Việc giải thích format_spec sẽ phụ thuộc vào loại đối số giá trị; . Ngôn ngữ nhỏ đặc tả định dạng .
Định dạng_spec mặc định là một chuỗi trống, thường mang lại tác dụng tương tự như khi gọi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']10
Một cuộc gọi đến
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']11 được dịch sang
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']12 bỏ qua từ điển cá thể khi tìm kiếm phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']13 của giá trị. Một ngoại lệ
class C: @classmethod def f[cls, arg1, arg2]: ...407 được đưa ra nếu tìm kiếm phương thức đạt tới
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']15 và format_spec không trống hoặc nếu format_spec hoặc giá trị trả về không phải là chuỗi
Đã thay đổi trong phiên bản 3. 4. ______316 tăng
class C: @classmethod def f[cls, arg1, arg2]: ...407 nếu format_spec không phải là một chuỗi rỗng. lớp đóng băng[có thể lặp lại=set[]]
Trả về một đối tượng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']18 mới, tùy chọn với các phần tử được lấy từ iterable.
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']18 là một lớp tích hợp. Xem
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']18 và Loại thiết lập — set, freezeset để biết tài liệu về lớp này.
Đối với các vùng chứa khác, hãy xem các lớp
class C: @classmethod def f[cls, arg1, arg2]: ...437,
class C: @classmethod def f[cls, arg1, arg2]: ...436,
class C: @classmethod def f[cls, arg1, arg2]: ...438 và
class C: @classmethod def f[cls, arg1, arg2]: ...434 tích hợp sẵn, cũng như mô-đun
class C: @classmethod def f[cls, arg1, arg2]: ...439getattr[đối tượng , tên]¶getattr[object, name, default]
Trả về giá trị của thuộc tính được đặt tên của đối tượng. tên phải là một chuỗi. Nếu chuỗi là tên của một trong các thuộc tính của đối tượng, thì kết quả là giá trị của thuộc tính đó. Ví dụ,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']26 tương đương với
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']27. Nếu thuộc tính được đặt tên không tồn tại, giá trị mặc định sẽ được trả về nếu được cung cấp, nếu không thì
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']28 sẽ được nâng lên. tên không cần phải là mã định danh Python [xem
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93]
Ghi chú
Vì việc xáo trộn tên riêng xảy ra vào thời điểm biên dịch, người ta phải xáo trộn tên của một thuộc tính riêng [các thuộc tính có hai dấu gạch dưới ở đầu] theo cách thủ công để .
toàn cầu[] ¶Trả về từ điển triển khai không gian tên mô-đun hiện tại. Đối với mã bên trong hàm, giá trị này được đặt khi hàm được xác định và giữ nguyên bất kể hàm được gọi ở đâu
hasattr[đối tượng , tên]¶Các đối số là một đối tượng và một chuỗi. Kết quả là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu chuỗi là tên của một trong các thuộc tính của đối tượng,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914 nếu không. [Điều này được thực hiện bằng cách gọi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']33 và xem liệu nó có tăng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']28 hay không. ]hàm băm[đối tượng] ¶
Trả về giá trị băm của đối tượng [nếu có]. Giá trị băm là số nguyên. Chúng được sử dụng để so sánh nhanh các khóa từ điển trong quá trình tra cứu từ điển. Các giá trị số so sánh bằng nhau có cùng giá trị băm [ngay cả khi chúng thuộc các loại khác nhau, như trường hợp của 1 và 1. 0]
Ghi chú
Đối với các đối tượng có phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']35 tùy chỉnh, lưu ý rằng
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']35 để biết chi tiếttrợ giúp[] ¶ trợ giúp[request]
Gọi hệ thống trợ giúp tích hợp. [Chức năng này dành cho sử dụng tương tác. ] Nếu không có đối số nào được đưa ra, hệ thống trợ giúp tương tác sẽ bắt đầu trên bảng điều khiển phiên dịch. Nếu đối số là một chuỗi, thì chuỗi đó được tra cứu dưới dạng tên của mô-đun, hàm, lớp, phương thức, từ khóa hoặc chủ đề tài liệu và trang trợ giúp được in trên bảng điều khiển. Nếu đối số là bất kỳ loại đối tượng nào khác, một trang trợ giúp về đối tượng sẽ được tạo
Lưu ý rằng nếu dấu gạch chéo [/] xuất hiện trong danh sách tham số của hàm khi gọi
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Chức năng này được thêm vào không gian tên tích hợp bởi mô-đun
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']39
Đã thay đổi trong phiên bản 3. 4. Các thay đổi đối với
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']40 và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']41 có nghĩa là các chữ ký được báo cáo cho các vật phẩm có thể gọi được hiện toàn diện và nhất quán hơn. hex[x] ¶
Chuyển đổi một số nguyên thành chuỗi thập lục phân chữ thường có tiền tố là “0x”. Nếu x không phải là một đối tượng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 của Python, thì nó phải xác định một phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922 trả về một số nguyên. Vài ví dụ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']91
Nếu bạn muốn chuyển đổi một số nguyên sang một chuỗi thập lục phân hoa hoặc thường có tiền tố hoặc không, bạn có thể sử dụng một trong hai cách sau
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']92
Xem thêm
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Xem thêm
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Ghi chú
Để có được biểu diễn chuỗi thập lục phân cho số float, hãy sử dụng phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']46id[đối tượng] ¶
Trả về “danh tính” của một đối tượng. Đây là một số nguyên được đảm bảo là duy nhất và không đổi cho đối tượng này trong suốt thời gian tồn tại của nó. Hai đối tượng có thời gian sống không chồng chéo có thể có cùng giá trị
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Chi tiết triển khai CPython. Đây là địa chỉ của đối tượng trong bộ nhớ
Tăng sự kiện kiểm tra
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']48 với đối số
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']49. đầu vào[] ¶ đầu vào[prompt]
Nếu có đối số dấu nhắc, nó sẽ được ghi vào đầu ra tiêu chuẩn mà không có dòng mới ở cuối. Sau đó, hàm đọc một dòng từ đầu vào, chuyển đổi nó thành một chuỗi [bỏ một dòng mới ở cuối] và trả về dòng đó. Khi EOF được đọc,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']50 được nâng lên. Ví dụ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93
Nếu mô-đun
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']51 đã được tải, thì
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Tăng sự kiện kiểm tra
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']53 với đối số
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']54 trước khi đọc đầu vào
Tăng sự kiện kiểm tra
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']55 với kết quả sau khi đọc thành công đầu vào. class int[x=0]¶class int[x, base=10]
Trả về một đối tượng số nguyên được tạo từ một số hoặc chuỗi x hoặc trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']992 nếu không có đối số nào được đưa ra. Nếu x định nghĩa
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']57,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']58 trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']59. Nếu x định nghĩa
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922, nó trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']61. Nếu x định nghĩa
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']62, nó trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']63. Đối với các số dấu phẩy động, số này cắt ngắn về 0
Nếu x không phải là một số hoặc nếu cơ số được đưa ra, thì x phải là một chuỗi, đối tượng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']945 hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']944 đại diện cho một số nguyên trong cơ số. Theo tùy chọn, chuỗi có thể được bắt đầu bằng
class C: @classmethod def f[cls, arg1, arg2]: ...422 hoặc
class C: @classmethod def f[cls, arg1, arg2]: ...423 [không có khoảng trắng ở giữa], có các số 0 ở đầu, được bao quanh bởi khoảng trắng và có một dấu gạch dưới nằm xen kẽ giữa các chữ số
Một chuỗi số nguyên cơ số n chứa các chữ số, mỗi chữ số đại diện cho một giá trị từ 0 đến n-1. Các giá trị 0–9 có thể được biểu thị bằng bất kỳ chữ số thập phân Unicode nào. Các giá trị 10–35 có thể được biểu thị bằng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']68 đến
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']69 [hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']70 đến
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']71]. Cơ sở mặc định là 10. Các cơ số được phép là 0 và 2–36. Các chuỗi cơ sở 2, -8 và -16 có thể được thêm tiền tố tùy chọn bằng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']72/
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']73,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']74/
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']75 hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']76/
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']77, như với các ký tự số nguyên trong mã. Đối với cơ số 0, chuỗi được hiểu theo cách tương tự như chữ số nguyên trong mã , trong đó cơ số thực là 2, 8, 10 hoặc . Cơ sở 0 cũng không cho phép các số 0 đứng đầu.
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']78 là không hợp pháp, trong khi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']79 và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']80 là.
Kiểu số nguyên được mô tả trong Kiểu số — int, float, complex .
Đã thay đổi trong phiên bản 3. 4. Nếu cơ sở không phải là một thể hiện của
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 và đối tượng cơ sở có một phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']82, thì phương thức đó được gọi để lấy một số nguyên cho cơ sở. Các phiên bản trước sử dụng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']83 thay vì
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']82.
Đã thay đổi trong phiên bản 3. 6. Cho phép nhóm các chữ số có dấu gạch dưới như trong mã chữ.
Đã thay đổi trong phiên bản 3. 7. x hiện là tham số chỉ vị trí.
Đã thay đổi trong phiên bản 3. 8. Trở về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922 nếu không xác định được
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']57.
Đã thay đổi trong phiên bản 3. 11. Ủy quyền cho
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']62 không được dùng nữa.
Đã thay đổi trong phiên bản 3. 11. ______6921 đầu vào chuỗi và biểu diễn chuỗi có thể được giới hạn để giúp tránh các cuộc tấn công từ chối dịch vụ. Một
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']963 được nâng lên khi vượt quá giới hạn trong khi chuyển đổi một chuỗi x thành một
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 hoặc khi chuyển đổi một
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 thành một chuỗi sẽ vượt quá giới hạn. Xem tài liệu giới hạn độ dài chuyển đổi chuỗi số nguyên . isinstance[đối tượng , classinfo]¶
Trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu đối số đối tượng là một thể hiện của đối số classinfo hoặc của một lớp con [trực tiếp, gián tiếp hoặc ảo ] của nó. Nếu đối tượng không phải là đối tượng của loại đã cho, hàm luôn trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914. Nếu classinfo là một bộ gồm các đối tượng loại [hoặc theo cách đệ quy, các bộ khác như vậy] hoặc một Loại liên kết gồm nhiều loại, hãy trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu đối tượng là một thể hiện của . Nếu classinfo không phải là một loại hoặc bộ dữ liệu của các loại và các bộ dữ liệu như vậy, một ngoại lệ
class C: @classmethod def f[cls, arg1, arg2]: ...407 được đưa ra.
class C: @classmethod def f[cls, arg1, arg2]: ...407 có thể không được nâng lên đối với loại không hợp lệ nếu lần kiểm tra trước đó thành công.
Đã thay đổi trong phiên bản 3. 10. classinfo có thể là một Loại Liên minh .
issubclass[class , classinfo]¶Trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu lớp là lớp con [trực tiếp, gián tiếp hoặc ảo ] của classinfo. Một lớp được coi là một lớp con của chính nó. classinfo có thể là một bộ gồm các đối tượng lớp [hoặc theo cách đệ quy, các bộ khác như vậy] hoặc một Kiểu liên kết , trong trường hợp này trả về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 nếu lớp là một lớp con của . Trong bất kỳ trường hợp nào khác, một ngoại lệ
class C: @classmethod def f[cls, arg1, arg2]: ...407 được đưa ra.
Đã thay đổi trong phiên bản 3. 10. classinfo có thể là một Loại Liên minh .
iter[đối tượng] ¶ iter[object, sentinel]Trả về một đối tượng iterator . Đối số đầu tiên được diễn giải rất khác nhau tùy thuộc vào sự hiện diện của đối số thứ hai. Không có đối số thứ hai, đối tượng phải là một đối tượng tập hợp hỗ trợ giao thức có thể lặp lại [phương thức
class C: @classmethod def f[cls, arg1, arg2]: ...00] hoặc nó phải hỗ trợ giao thức trình tự [phương thức
class C: @classmethod def f[cls, arg1, arg2]: ...01 . Nếu nó không hỗ trợ một trong hai giao thức đó, thì
class C: @classmethod def f[cls, arg1, arg2]: ...407 sẽ được nâng lên. Nếu đối số thứ hai, sentinel, được đưa ra, thì đối tượng phải là đối tượng có thể gọi được. Trình vòng lặp được tạo trong trường hợp này sẽ gọi đối tượng không có đối số cho mỗi lệnh gọi đến phương thức
class C: @classmethod def f[cls, arg1, arg2]: ...455 của nó; .
Xem thêm Các loại trình lặp .
One useful application of the second form of
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']92 is to build a block-reader. Ví dụ: đọc các khối có chiều rộng cố định từ tệp cơ sở dữ liệu nhị phân cho đến khi đạt đến cuối tệp
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']94len[s] ¶
Trả về chiều dài [số lượng mục] của một đối tượng. The argument may be a sequence [such as a string, bytes, tuple, list, or range] or a collection [such as a dictionary, set, or frozen set]
Chi tiết triển khai CPython.
class C: @classmethod def f[cls, arg1, arg2]: ...07 raises
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']01 on lengths larger than
class C: @classmethod def f[cls, arg1, arg2]: ...09, such as
class C: @classmethod def f[cls, arg1, arg2]: ...10lớp danh sáchlớp danh sách[iterable]
Thay vì là một hàm,
class C: @classmethod def f[cls, arg1, arg2]: ...436 thực sự là một loại trình tự có thể thay đổi, như được ghi lại trong Danh sách và Sequence Types — list, tuple, range.người dân địa phương[] ¶
Cập nhật và trả về một từ điển đại diện cho bảng ký hiệu cục bộ hiện tại. Các biến miễn phí được trả về bởi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95 khi nó được gọi trong các khối chức năng, nhưng không phải trong các khối lớp. Lưu ý rằng ở cấp độ mô-đun,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95 và
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Ghi chú
The contents of this dictionary should not be modified; changes may not affect the values of local and free variables used by the interpreter
map[function , iterable , *iterables] ¶Return an iterator that applies function to every item of iterable, yielding the results. If additional iterables arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see
class C: @classmethod def f[cls, arg1, arg2]: ...15max[iterable , * , key=None] ¶ max[iterable , * , default , key=None]max[arg1 , arg2 , *args , key=None]
Return the largest item in an iterable or the largest of two or more arguments
Nếu một đối số vị trí được cung cấp, thì đó phải là một có thể lặp lại . The largest item in the iterable is returned. If two or more positional arguments are provided, the largest of the positional arguments is returned.
There are two optional keyword-only arguments. The key argument specifies a one-argument ordering function like that used for
class C: @classmethod def f[cls, arg1, arg2]: ...16. The default argument specifies an object to return if the provided iterable is empty. If the iterable is empty and default is not provided, a
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']963 is raised
If multiple items are maximal, the function returns the first one encountered. This is consistent with other sort-stability preserving tools such as
class C: @classmethod def f[cls, arg1, arg2]: ...18 and
class C: @classmethod def f[cls, arg1, arg2]: ...19
New in version 3. 4. The default keyword-only argument.
Changed in version 3. 8. The key can be
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983. class memoryview[object]
Return a “memory view” object created from the given argument. See Memory Views for more information.
min[iterable , * , key=None] ¶ min[iterable , * , default , key=None]min[arg1 , arg2 , *args , key=None]Trả về mục nhỏ nhất trong một lần lặp hoặc mục nhỏ nhất trong hai hoặc nhiều đối số
Nếu một đối số vị trí được cung cấp, thì đó phải là một có thể lặp lại . Mục nhỏ nhất trong iterable được trả về. Nếu hai hoặc nhiều đối số vị trí được cung cấp, đối số vị trí nhỏ nhất được trả về.
There are two optional keyword-only arguments. The key argument specifies a one-argument ordering function like that used for
class C: @classmethod def f[cls, arg1, arg2]: ...16. The default argument specifies an object to return if the provided iterable is empty. If the iterable is empty and default is not provided, a
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']963 is raised
Nếu nhiều mục là tối thiểu, hàm trả về mục đầu tiên gặp phải. Điều này phù hợp với các công cụ bảo quản tính ổn định sắp xếp khác như
class C: @classmethod def f[cls, arg1, arg2]: ...23 và
class C: @classmethod def f[cls, arg1, arg2]: ...24
New in version 3. 4. The default keyword-only argument.
Changed in version 3. 8. The key can be
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983. next[iterator] ¶ next[iterator, default]
Truy xuất mục tiếp theo từ trình lặp bằng cách gọi phương thức
class C: @classmethod def f[cls, arg1, arg2]: ...455 của nó. Nếu giá trị mặc định được đưa ra, nó sẽ được trả về nếu bộ vòng lặp đã cạn kiệt, nếu không thì
class C: @classmethod def f[cls, arg1, arg2]: ...05 được nâng lên. lớp đối tượng ¶
Trả lại một đối tượng đặc biệt mới.
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']15 là cơ sở cho tất cả các lớp. Nó có các phương thức phổ biến cho tất cả các phiên bản của các lớp Python. Chức năng này không chấp nhận bất kỳ đối số
Ghi chú
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']15 không có
class C: @classmethod def f[cls, arg1, arg2]: ...445, vì vậy bạn không thể gán các thuộc tính tùy ý cho một thể hiện của lớp
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']15oct[x] ¶
Chuyển đổi một số nguyên thành một chuỗi bát phân có tiền tố là “0o”. Kết quả là một biểu thức Python hợp lệ. Nếu x không phải là một đối tượng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 của Python, thì nó phải xác định một phương thức
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922 trả về một số nguyên. Ví dụ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95
Nếu bạn muốn chuyển đổi một số nguyên thành một chuỗi bát phân có tiền tố “0o” hoặc không, bạn có thể sử dụng một trong hai cách sau
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']96
Xem thêm
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] mở[tệp , chế độ='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None]¶
Mở tệp và trả về đối tượng tệp tương ứng . Nếu tệp không thể mở được, một
class C: @classmethod def f[cls, arg1, arg2]: ...35 sẽ xuất hiện. Xem Đọc và ghi tệp để biết thêm ví dụ về cách sử dụng chức năng này.
tệp là một đối tượng dạng đường dẫn cung cấp tên đường dẫn [tuyệt đối hoặc liên quan đến thư mục làm việc hiện tại] của tệp sẽ được mở hoặc . [Nếu một bộ mô tả tệp được cung cấp, nó sẽ bị đóng khi đối tượng I/O được trả về bị đóng trừ khi closefd được đặt thành
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914. ]
chế độ là một chuỗi tùy chọn chỉ định chế độ mở tệp. Nó mặc định là
class C: @classmethod def f[cls, arg1, arg2]: ...37 có nghĩa là mở để đọc ở chế độ văn bản. Các giá trị phổ biến khác là
class C: @classmethod def f[cls, arg1, arg2]: ...38 để ghi [cắt bớt tệp nếu nó đã tồn tại],
class C: @classmethod def f[cls, arg1, arg2]: ...39 để tạo độc quyền và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']959 để nối thêm [trên một số hệ thống Unix, có nghĩa là tất cả các ghi sẽ nối vào cuối tệp bất kể vị trí tìm kiếm hiện tại . Ở chế độ văn bản, nếu mã hóa không được chỉ định thì mã hóa được sử dụng phụ thuộc vào nền tảng.
class C: @classmethod def f[cls, arg1, arg2]: ...41 được gọi để lấy mã hóa miền địa phương hiện tại. [Để đọc và ghi byte thô, hãy sử dụng chế độ nhị phân và để mã hóa không xác định. ] Các chế độ khả dụng là
Nhân vật
Nghĩa
class C: @classmethod def f[cls, arg1, arg2]: ...37
mở để đọc [mặc định]
class C: @classmethod def f[cls, arg1, arg2]: ...38
mở để viết, cắt bớt tệp trước
class C: @classmethod def f[cls, arg1, arg2]: ...39
mở để tạo độc quyền, không thành công nếu tệp đã tồn tại
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']959
mở để viết, thêm vào cuối tệp nếu nó tồn tại
class C: @classmethod def f[cls, arg1, arg2]: ...46
chế độ nhị phân
class C: @classmethod def f[cls, arg1, arg2]: ...47
chế độ văn bản [mặc định]
class C: @classmethod def f[cls, arg1, arg2]: ...495
mở để cập nhật [đọc và viết]
Chế độ mặc định là
class C: @classmethod def f[cls, arg1, arg2]: ...37 [mở để đọc văn bản, một từ đồng nghĩa của
class C: @classmethod def f[cls, arg1, arg2]: ...50]. Chế độ
class C: @classmethod def f[cls, arg1, arg2]: ...51 và
class C: @classmethod def f[cls, arg1, arg2]: ...52 mở và cắt bớt tệp. Chế độ
class C: @classmethod def f[cls, arg1, arg2]: ...53 và
class C: @classmethod def f[cls, arg1, arg2]: ...54 mở tệp mà không cắt bớt
Như đã đề cập trong Tổng quan , Python phân biệt giữa I/O nhị phân và văn bản. Các tệp được mở ở chế độ nhị phân [bao gồm cả
class C: @classmethod def f[cls, arg1, arg2]: ...46 trong đối số chế độ] trả về nội dung dưới dạng đối tượng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']945 mà không cần giải mã. Ở chế độ văn bản [mặc định hoặc khi
class C: @classmethod def f[cls, arg1, arg2]: ...47 được bao gồm trong đối số chế độ], nội dung của tệp được trả về dưới dạng
class C: @classmethod def f[cls, arg1, arg2]: ...58, các byte đã được giải mã lần đầu bằng mã hóa phụ thuộc vào nền tảng hoặc sử dụng mã hóa được chỉ định nếu được cung cấp.
Ghi chú
Python không phụ thuộc vào khái niệm tệp văn bản của hệ điều hành cơ bản;
đệm là một số nguyên tùy chọn được sử dụng để đặt chính sách đệm. Vượt qua 0 để tắt bộ đệm [chỉ được phép ở chế độ nhị phân], 1 để chọn bộ đệm dòng [chỉ có thể sử dụng ở chế độ văn bản] và một số nguyên > 1 để biểu thị kích thước tính bằng byte của bộ đệm khối có kích thước cố định. Lưu ý rằng việc chỉ định kích thước bộ đệm theo cách này áp dụng cho I/O được đệm nhị phân, nhưng
class C: @classmethod def f[cls, arg1, arg2]: ...59 [i. e. , các tệp được mở bằng
class C: @classmethod def f[cls, arg1, arg2]: ...60] sẽ có một bộ đệm khác. Để vô hiệu hóa bộ đệm trong
class C: @classmethod def f[cls, arg1, arg2]: ...59, hãy cân nhắc sử dụng cờ
class C: @classmethod def f[cls, arg1, arg2]: ...62 cho
class C: @classmethod def f[cls, arg1, arg2]: ...63. Khi không đưa ra đối số đệm, chính sách đệm mặc định hoạt động như sau
Các tệp nhị phân được đệm trong các khối có kích thước cố định; . Trên nhiều hệ thống, bộ đệm thường dài 4096 hoặc 8192 byte
Tệp văn bản “tương tác” [tệp mà
class C: @classmethod def f[cls, arg1, arg2]: ...
65 trả về>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
909] sử dụng bộ đệm dòng. Các tệp văn bản khác sử dụng chính sách được mô tả ở trên cho các tệp nhị phân
encoding là tên của mã hóa được sử dụng để giải mã hoặc mã hóa tệp. Điều này chỉ nên được sử dụng trong chế độ văn bản. Mã hóa mặc định phụ thuộc vào nền tảng [bất kỳ giá trị nào mà
class C: @classmethod def f[cls, arg1, arg2]: ...41 trả về], nhưng bất kỳ mã hóa văn bản nào được Python hỗ trợ đều có thể được sử dụng. Xem mô-đun
class C: @classmethod def f[cls, arg1, arg2]: ...68 để biết danh sách mã hóa được hỗ trợ.
lỗi là một chuỗi tùy chọn chỉ định cách xử lý lỗi mã hóa và giải mã—không thể sử dụng chuỗi này trong chế độ nhị phân. Có sẵn nhiều trình xử lý lỗi tiêu chuẩn [được liệt kê trong Trình xử lý lỗi ], mặc dù bất kỳ tên xử lý lỗi nào đã được đăng ký với
class C: @classmethod def f[cls, arg1, arg2]: ...69 cũng hợp lệ. Tên tiêu chuẩn bao gồm.
class C: @classmethod def f[cls, arg1, arg2]: ...
70 để đưa ra một ngoại lệ>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
963 nếu có lỗi mã hóa. Giá trị mặc định của>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
983 có tác dụng tương tựclass C: @classmethod def f[cls, arg1, arg2]: ...
73 bỏ qua lỗi. Lưu ý rằng bỏ qua lỗi mã hóa có thể dẫn đến mất dữ liệuclass C: @classmethod def f[cls, arg1, arg2]: ...
74 khiến một điểm đánh dấu thay thế [chẳng hạn nhưclass C: @classmethod def f[cls, arg1, arg2]: ...
75] được chèn vào nơi có dữ liệu không đúng định dạngclass C: @classmethod def f[cls, arg1, arg2]: ...
76 sẽ đại diện cho bất kỳ byte không chính xác nào dưới dạng đơn vị mã thay thế thấp, từ U+DC80 đến U+DCFF. Các đơn vị mã thay thế này sau đó sẽ được chuyển trở lại thành các byte giống nhau khi trình xử lý lỗiclass C: @classmethod def f[cls, arg1, arg2]: ...
77 được sử dụng khi ghi dữ liệu. Điều này hữu ích để xử lý các tệp ở dạng mã hóa không xác địnhclass C: @classmethod def f[cls, arg1, arg2]: ...
78 chỉ được hỗ trợ khi ghi vào tệp. Characters not supported by the encoding are replaced with the appropriate XML character referenceclass C: @classmethod def f[cls, arg1, arg2]: ...
79________ 980 thay thế dữ liệu không đúng định dạng bằng chuỗi thoát dấu gạch chéo ngược Python
class C: @classmethod def f[cls, arg1, arg2]: ...
81 [cũng chỉ được hỗ trợ khi viết] thay thế các ký tự không được hỗ trợ bằng chuỗi thoátclass C: @classmethod def f[cls, arg1, arg2]: ...
82
dòng mới xác định cách phân tích các ký tự dòng mới từ luồng. Nó có thể là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983,
class C: @classmethod def f[cls, arg1, arg2]: ...84,
class C: @classmethod def f[cls, arg1, arg2]: ...85,
class C: @classmethod def f[cls, arg1, arg2]: ...86 và
class C: @classmethod def f[cls, arg1, arg2]: ...87. Nó hoạt động như sau
Khi đọc đầu vào từ luồng, nếu dòng mới là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
983, chế độ dòng mới chung được bật. Các dòng trong đầu vào có thể kết thúc bằngclass C: @classmethod def f[cls, arg1, arg2]: ...
85,class C: @classmethod def f[cls, arg1, arg2]: ...
86 hoặcclass C: @classmethod def f[cls, arg1, arg2]: ...
87 và những dòng này được dịch thànhclass C: @classmethod def f[cls, arg1, arg2]: ...
85 trước khi được trả lại cho người gọi. Nếu làclass C: @classmethod def f[cls, arg1, arg2]: ...
84, chế độ dòng mới chung được bật, nhưng kết thúc dòng được trả lại cho trình gọi chưa được dịch. Nếu nó có bất kỳ giá trị pháp lý nào khác, các dòng đầu vào chỉ được kết thúc bởi chuỗi đã cho và kết thúc dòng được trả về cho người gọi chưa được dịchKhi ghi đầu ra vào luồng, nếu dòng mới là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
983, mọi ký tựclass C: @classmethod def f[cls, arg1, arg2]: ...
85 được ghi sẽ được dịch sang dấu phân cách dòng mặc định của hệ thống,class C: @classmethod def f[cls, arg1, arg2]: ...
96. Nếu dòng mới làclass C: @classmethod def f[cls, arg1, arg2]: ...
84 hoặcclass C: @classmethod def f[cls, arg1, arg2]: ...
85, không có bản dịch nào diễn ra. Nếu dòng mới là bất kỳ giá trị pháp lý nào khác, bất kỳ ký tựclass C: @classmethod def f[cls, arg1, arg2]: ...
85 nào được viết sẽ được dịch sang chuỗi đã cho
Nếu closefd là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']914 và một bộ mô tả tệp thay vì tên tệp đã được cung cấp, bộ mô tả tệp cơ bản sẽ được giữ mở khi đóng tệp. Nếu tên tệp được cung cấp closefd phải là
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909 [mặc định];
Có thể sử dụng công cụ mở tùy chỉnh bằng cách chuyển một công cụ mở có thể gọi được. Bộ mô tả tệp cơ bản cho đối tượng tệp sau đó được lấy bằng cách gọi trình mở với [tệp, cờ]. opener must return an open file descriptor [passing
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983]
The newly created file is non-inheritable .
The following example uses the dir_fd parameter of the
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97
Loại đối tượng tệp được trả về bởi hàm
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93 tùy thuộc vào chế độ. Khi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93 được sử dụng để mở tệp ở chế độ văn bản [
class C: @classmethod def f[cls, arg1, arg2]: ...38,
class C: @classmethod def f[cls, arg1, arg2]: ...37,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] class C: @classmethod def f[cls, arg1, arg2]: ...50, v.v. ], nó trả về một lớp con của
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] See also the file handling modules, such as
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93 is declared],
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Raises an auditing event
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] The
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Changed in version 3. 3
The opener parameter was added
The
class C: @classmethod def f[cls, arg1, arg2]: ...
39 mode was added
933 used to be raised, it is now an alias ofa = 2 b = 4 c = 6 # a^b%c print[pow[a, b, c]]class C: @classmethod def f[cls, arg1, arg2]: ...
35
935 is now raised if the file opened in exclusive creation mode [a = 2 b = 4 c = 6 # a^b%c print[pow[a, b, c]]class C: @classmethod def f[cls, arg1, arg2]: ...
39] already exists
Changed in version 3. 4
The file is now non-inheritable
Changed in version 3. 5
If the system call is interrupted and the signal handler does not raise an exception, the function now retries the system call instead of raising an
937 exception [see PEP 475 for the rationale]a = 2 b = 4 c = 6 # a^b%c print[pow[a, b, c]]The
class C: @classmethod def f[cls, arg1, arg2]: ...
81 error handler was added
Changed in version 3. 6
Support added to accept objects implementing
939a = 2 b = 4 c = 6 # a^b%c print[pow[a, b, c]]On Windows, opening a console buffer may return a subclass of
917 other thana = 2 b = 4 c = 6 # a^b%c print[pow[a, b, c]]
918a = 2 b = 4 c = 6 # a^b%c print[pow[a, b, c]]
Changed in version 3. 11. The
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Given a string representing one Unicode character, return an integer representing the Unicode code point of that character. For example,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] class C: @classmethod def f[cls, arg1, arg2]: ...6pow[base , exp , mod=None] ¶
Return base to the power exp; if mod is present, return base to the power exp, modulo mod [computed more efficiently than
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 operands, the result has the same type as the operands [after coercion] unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 or
class C: @classmethod def f[cls, arg1, arg2]: ...413 and a non-integral exponent, a complex result is delivered. For example,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] For
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 operands base and exp, if mod is present, mod must also be of integer type and mod must be nonzero. If mod is present and exp is negative, base must be relatively prime to mod. In that case,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Here’s an example of computing an inverse for
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']98
Changed in version 3. 8. For
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']921 operands, the three-argument form of
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Changed in version 3. 8. Allow keyword arguments. Formerly, only positional arguments were supported.
print[*objects , sep=' ' , end='\n' , file=None , flush=False] ¶Print objects to the text stream file, separated by sep and followed by end. sep, end, file, and flush, if present, must be given as keyword arguments
All non-keyword arguments are converted to strings like
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97 does and written to the stream, separated by sep and followed by end. Both sep and end must be strings; they can also be
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983, which means to use the default values. If no objects are given,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']96 will just write end
The file argument must be an object with a
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']96 cannot be used with binary mode file objects. For these, use
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Whether the output is buffered is usually determined by file, but if the flush keyword argument is true, the stream is forcibly flushed
Changed in version 3. 3. Đã thêm đối số từ khóa flush.
class property[fget=None , fset=None , fdel=None , doc=None] ¶Return a property attribute
fget is a function for getting an attribute value. fset is a function for setting an attribute value. fdel is a function for deleting an attribute value. And doc creates a docstring for the attribute
A typical use is to define a managed attribute
class C: @classmethod def f[cls, arg1, arg2]: ...415
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99
If c is an instance of C,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] If given, doc will be the docstring of the property attribute. Otherwise, the property will copy fget’s docstring [if it exists]. This makes it possible to create read-only properties easily using
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97 as a decorator .
class C: @classmethod def f[cls, arg1, arg2]: ...40
The
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] A property object has
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] class C: @classmethod def f[cls, arg1, arg2]: ...41
This code is exactly equivalent to the first example. Be sure to give the additional functions the same name as the original property [
class C: @classmethod def f[cls, arg1, arg2]: ...415 in this case. ]
The returned property object also has the attributes
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Changed in version 3. 5. The docstrings of property objects are now writeable.
class range[stop]class range[start , stop , step=1]Rather than being a function,
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] Return a string containing a printable representation of an object. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']941reversed[seq] ¶
Return a reverse iterator . seq must be an object which has a
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] class C: @classmethod def f[cls, arg1, arg2]: ...01 method with integer arguments starting at
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']992]. round[number , ndigits=None] ¶
Return number rounded to ndigits precision after the decimal point. If ndigits is omitted or is
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983, it returns the nearest integer to its input
For the built-in types supporting
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']91, values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice [so, for example, both
a = 2
b = 4
c = 6
# a^b%c
print[pow[a, b, c]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']992, and
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']996]. Any integer value is valid for ndigits [positive, zero, or negative]. The return value is an integer if ndigits is omitted or
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983. Otherwise, the return value has the same type as number
For a general Python object
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Ghi chú
The behavior of
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']91 for floats can be surprising. for example,
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Return a new
class C: @classmethod def f[cls, arg1, arg2]: ...437 object, optionally with elements taken from iterable.
class C: @classmethod def f[cls, arg1, arg2]: ...437 is a built-in class. See
class C: @classmethod def f[cls, arg1, arg2]: ...437 and Set Types — set, frozenset for documentation about this class.
For other containers see the built-in
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']18,
class C: @classmethod def f[cls, arg1, arg2]: ...436,
class C: @classmethod def f[cls, arg1, arg2]: ...438, and
class C: @classmethod def f[cls, arg1, arg2]: ...434 classes, as well as the
class C: @classmethod def f[cls, arg1, arg2]: ...439 modulesetattr[object , name , value] ¶
This is the counterpart of
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] name need not be a Python identifier as defined in Identifiers and keywords unless the object chooses to enforce that, for example in a custom
class C: @classmethod def f[cls, arg1, arg2]: ...442 or via
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Ghi chú
Since private name mangling happens at compilation time, one must manually mangle a private attribute’s [attributes with two leading underscores] name in order to set it with
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']93. class slice[stop] ¶ class slice[start , stop , step=1]
Return a slice object representing the set of indices specified by
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983. Slice objects have read-only data attributes
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Return a new sorted list from the items in iterable
Có hai đối số tùy chọn phải được chỉ định làm đối số từ khóa
key specifies a function of one argument that is used to extract a comparison key from each element in iterable [for example,
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']983 [compare the elements directly]
reverse is a boolean value. If set to
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']909, then the list elements are sorted as if each comparison were reversed
Use
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] The built-in
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95 function is guaranteed to be stable. A sort is stable if it guarantees not to change the relative order of elements that compare equal — this is helpful for sorting in multiple passes [for example, sort by department, then by salary grade]
The sort algorithm uses only
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97 that rely on a different underlying method. Implementing all six comparisons also helps avoid confusion for mixed type comparisons which can call reflected the
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] For sorting examples and a brief sorting tutorial, see Sorting HOW TO .
@phương thức tĩnh ¶Transform a method into a static method
Một phương thức tĩnh không nhận được đối số đầu tiên ngầm định. Để khai báo một phương thức tĩnh, hãy sử dụng thành ngữ này
class C: @classmethod def f[cls, arg1, arg2]: ...42
Biểu mẫu
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Một phương thức tĩnh có thể được gọi trên lớp [chẳng hạn như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']965] hoặc trên một thể hiện [chẳng hạn như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']966]. Hơn nữa, chúng có thể được gọi là các hàm thông thường [chẳng hạn như
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Các phương thức tĩnh trong Python tương tự như các phương thức được tìm thấy trong Java hoặc C++. Ngoài ra, hãy xem
class C: @classmethod def f[cls, arg1, arg2]: ...7 để biết một biến thể hữu ích để tạo các hàm tạo lớp thay thế
Giống như tất cả các bộ trang trí, cũng có thể gọi
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] class C: @classmethod def f[cls, arg1, arg2]: ...43
Để biết thêm thông tin về các phương thức tĩnh, hãy xem Hệ thống phân cấp loại tiêu chuẩn .
Đã thay đổi trong phiên bản 3. 10. Các phương thức tĩnh hiện kế thừa các thuộc tính của phương thức [
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']969,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']970,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']971,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']972 và
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']973], có thuộc tính
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']974 mới và hiện có thể gọi được như các hàm thông thường. lớp str[đối tượng='']class str[object=b'', encoding='utf-8', errors='strict']
Trả về phiên bản đối tượng
class C: @classmethod def f[cls, arg1, arg2]: ...58. Xem
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']97 để biết chi tiết
class C: @classmethod def f[cls, arg1, arg2]: ...58 là chuỗi tích hợp sẵn class . Để biết thông tin chung về chuỗi, hãy xem Loại chuỗi văn bản — str . sum[có thể lặp lại , /, start=0]¶
Tính tổng bắt đầu và các mục của một lần lặp từ trái sang phải và trả về tổng. Các mục của iterable thường là các số và giá trị bắt đầu không được phép là một chuỗi
Đối với một số trường hợp sử dụng, có những lựa chọn thay thế tốt cho
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']98. Cách ưa thích, nhanh chóng để nối một chuỗi các chuỗi là gọi ____
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Đã thay đổi trong phiên bản 3. 8. Tham số bắt đầu có thể được chỉ định làm đối số từ khóa.
hạng siêu ¶ hạng siêu[type, object_or_type=None]Trả về một đối tượng proxy ủy thác các cuộc gọi phương thức cho một loại cha hoặc anh chị em. Điều này rất hữu ích để truy cập các phương thức kế thừa đã bị ghi đè trong một lớp
Object_or_type xác định thứ tự giải quyết phương pháp được tìm kiếm. Việc tìm kiếm bắt đầu từ lớp ngay sau loại.
Ví dụ: nếu
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99 tìm kiếm
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Thuộc tính
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99. Thuộc tính động và có thể thay đổi bất cứ khi nào hệ thống phân cấp thừa kế được cập nhật
Nếu đối số thứ hai bị bỏ qua, siêu đối tượng được trả về không bị ràng buộc. Nếu đối số thứ hai là một đối tượng, thì
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Có hai trường hợp sử dụng điển hình cho siêu. Trong một hệ thống phân cấp lớp với một kế thừa duy nhất, super có thể được sử dụng để chỉ các lớp cha mà không cần đặt tên rõ ràng cho chúng, do đó làm cho mã dễ bảo trì hơn. Việc sử dụng này gần giống với việc sử dụng super trong các ngôn ngữ lập trình khác
Trường hợp sử dụng thứ hai là hỗ trợ đa kế thừa hợp tác trong môi trường thực thi động. Trường hợp sử dụng này là duy nhất đối với Python và không có trong các ngôn ngữ được biên dịch tĩnh hoặc các ngôn ngữ chỉ hỗ trợ kế thừa đơn lẻ. Điều này cho phép triển khai “sơ đồ kim cương” trong đó nhiều lớp cơ sở triển khai cùng một phương thức. Thiết kế tốt chỉ ra rằng các triển khai như vậy có chữ ký gọi giống nhau trong mọi trường hợp [vì thứ tự của các lệnh gọi được xác định trong thời gian chạy, vì thứ tự đó thích ứng với những thay đổi trong hệ thống phân cấp lớp và vì thứ tự đó có thể bao gồm các lớp anh chị em không xác định trước thời gian chạy
Đối với cả hai trường hợp sử dụng, một lệnh gọi siêu lớp điển hình trông như thế này
class C: @classmethod def f[cls, arg1, arg2]: ...44
Ngoài tra cứu phương thức,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99 còn hoạt động để tra cứu thuộc tính. Một trường hợp sử dụng khả thi cho việc này là gọi các bộ mô tả trong lớp cha hoặc lớp anh chị em.
Lưu ý rằng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99 được triển khai như một phần của quy trình ràng buộc để tra cứu thuộc tính chấm rõ ràng, chẳng hạn như
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] class C: @classmethod def f[cls, arg1, arg2]: ...442 của riêng mình để tìm kiếm các lớp theo thứ tự có thể dự đoán được, hỗ trợ đa kế thừa hợp tác. Theo đó,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99 không được xác định đối với các tra cứu ẩn bằng cách sử dụng các câu lệnh hoặc toán tử, chẳng hạn như
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Cũng lưu ý rằng, ngoài dạng đối số bằng 0,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99 không giới hạn việc sử dụng các phương thức bên trong. Dạng hai đối số chỉ định chính xác các đối số và đưa ra các tham chiếu phù hợp. Dạng đối số 0 chỉ hoạt động bên trong một định nghĩa lớp, vì trình biên dịch sẽ điền vào các chi tiết cần thiết để truy xuất chính xác lớp đang được định nghĩa, cũng như truy cập thể hiện hiện tại cho các phương thức thông thường
Để biết các đề xuất thực tế về cách thiết kế các lớp hợp tác bằng cách sử dụng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']99, hãy xem hướng dẫn sử dụng super[]lớp bộlớp bộ[iterable]
Thay vì là một hàm,
class C: @classmethod def f[cls, arg1, arg2]: ...438 thực sự là một loại trình tự bất biến, như được ghi lại trong Tuples và Sequence Types — list, tuple, range.lớp loại[đối tượng]¶class type[name, bases, dict, **kwds]
Với một đối số, trả về loại đối tượng. Giá trị trả về là một đối tượng kiểu và thường là cùng một đối tượng được trả về bởi
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Hàm tích hợp sẵn của
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']90 được khuyến nghị để kiểm tra loại đối tượng, vì nó tính đến các lớp con
Với ba đối số, trả về một đối tượng kiểu mới. Đây thực chất là một dạng động của câu lệnh
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] >>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']970. Bộ cơ sở chứa các lớp cơ sở và trở thành thuộc tính
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] class C: @classmethod def f[cls, arg1, arg2]: ...45
Xem thêm Loại đối tượng .
Các đối số từ khóa được cung cấp cho dạng ba đối số được chuyển đến bộ máy siêu dữ liệu thích hợp [thường là
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Xem thêm Tùy chỉnh việc tạo lớp học .
Đã thay đổi trong phiên bản 3. 6. Các lớp con của
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Trả về thuộc tính
class C: @classmethod def f[cls, arg1, arg2]: ...445 cho một mô-đun, lớp, thể hiện hoặc bất kỳ đối tượng nào khác có thuộc tính
class C: @classmethod def f[cls, arg1, arg2]: ...445
Các đối tượng như mô-đun và phiên bản có thuộc tính
class C: @classmethod def f[cls, arg1, arg2]: ...445 có thể cập nhật;
Không tranh cãi,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']902 hoạt động như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']95. Lưu ý, từ điển địa phương chỉ hữu ích cho việc đọc vì các cập nhật cho từ điển địa phương bị bỏ qua
Một ngoại lệ
class C: @classmethod def f[cls, arg1, arg2]: ...407 được đưa ra nếu một đối tượng được chỉ định nhưng nó không có thuộc tính
class C: @classmethod def f[cls, arg1, arg2]: ...445 [ví dụ: nếu lớp của nó xác định thuộc tính
import math
print [math.pow[10, 5]]
print [math.pow[10, -5]] Lặp lại song song nhiều lần lặp, tạo ra các bộ dữ liệu với một mục từ mỗi bộ
Ví dụ
class C: @classmethod def f[cls, arg1, arg2]: ...46
Chính thức hơn.
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']903 trả về một trình vòng lặp của các bộ dữ liệu, trong đó bộ thứ i chứa phần tử thứ i từ mỗi bộ lặp đối số
Một cách khác để nghĩ về
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']903 là nó biến hàng thành cột và cột thành hàng. Điều này tương tự như chuyển vị một ma trận
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']903 lười biếng. Các phần tử sẽ không được xử lý cho đến khi iterable được lặp lại trên, e. g. bởi một vòng lặp
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']906 hoặc bằng cách gói trong một
class C: @classmethod def f[cls, arg1, arg2]: ...436
Một điều cần xem xét là các lần lặp được chuyển đến
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']903 có thể có độ dài khác nhau; . Python cung cấp ba cách tiếp cận khác nhau để giải quyết vấn đề này
Theo mặc định,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
903 dừng khi hết thời gian lặp lại ngắn nhất. Nó sẽ bỏ qua các mục còn lại trong các lần lặp dài hơn, cắt kết quả theo độ dài của lần lặp ngắn nhấtclass C: @classmethod def f[cls, arg1, arg2]: ...
47>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
903 thường được sử dụng trong trường hợp các lần lặp được giả định là có độ dài bằng nhau. Trong những trường hợp như vậy, bạn nên sử dụng tùy chọn>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
911. Đầu ra của nó giống như>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
903 thông thườngclass C: @classmethod def f[cls, arg1, arg2]: ...
48Không giống như hành vi mặc định, nó sẽ tăng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
963 nếu một lần lặp cạn kiệt trước những lần lặp khácclass C: @classmethod def f[cls, arg1, arg2]: ...
49Nếu không có đối số
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
911, bất kỳ lỗi nào dẫn đến các lần lặp có độ dài khác nhau sẽ bị tắt tiếng, có thể biểu hiện dưới dạng một lỗi khó tìm trong một phần khác của chương trìnhCác lần lặp ngắn hơn có thể được đệm bằng một giá trị không đổi để làm cho tất cả các lần lặp có cùng độ dài. Điều này được thực hiện bởi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
915
trường hợp cạnh. Với một đối số có thể lặp lại duy nhất,
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']903 trả về một trình lặp gồm 1 bộ. Không có đối số, nó trả về một trình vòng lặp trống
Các mẹo và thủ thuật
Thứ tự đánh giá từ trái sang phải của các lần lặp được đảm bảo. Điều này có thể tạo thành một thành ngữ để phân cụm chuỗi dữ liệu thành các nhóm có độ dài n bằng cách sử dụng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
917. Điều này lặp lại cùng một trình lặp>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
918 lần để mỗi bộ dữ liệu đầu ra có kết quả của các lệnh gọi>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
918 đến trình lặp. Điều này có tác dụng chia đầu vào thành các khối có độ dài n>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
903 kết hợp với toán tử>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
921 có thể được sử dụng để giải nén danh sách>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']
0
Đã thay đổi trong phiên bản 3. 10. Đã thêm đối số
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']922. __import__[tên , toàn cầu=None, locals=None, fromlist=[], level=0]¶
Ghi chú
Đây là một chức năng nâng cao không cần thiết trong lập trình Python hàng ngày, không giống như
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']923
Hàm này được gọi bởi câu lệnh
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']924. Nó có thể được thay thế [bằng cách nhập mô-đun
class C: @classmethod def f[cls, arg1, arg2]: ...458 và gán cho
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']926] để thay đổi ngữ nghĩa của câu lệnh
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']924, nhưng làm như vậy không được khuyến khích vì sử dụng móc nhập [xem PEP 302] thường đơn giản hơn để đạt được các mục tiêu tương tự . Việc sử dụng trực tiếp
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']904 cũng không được khuyến khích để thay thế cho
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']923
Hàm nhập tên mô-đun, có khả năng sử dụng toàn cầu và cục bộ đã cho để xác định cách diễn giải tên trong ngữ cảnh gói. Danh sách từ cung cấp tên của các đối tượng hoặc mô hình con nên được nhập từ mô-đun được cung cấp theo tên. Việc triển khai tiêu chuẩn hoàn toàn không sử dụng đối số cục bộ của nó và chỉ sử dụng đối số toàn cục của nó để xác định ngữ cảnh gói của câu lệnh
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']924
level chỉ định sử dụng nhập khẩu tuyệt đối hay tương đối.
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']992 [mặc định] có nghĩa là chỉ thực hiện nhập tuyệt đối. Các giá trị dương cho level cho biết số lượng thư mục mẹ cần tìm kiếm liên quan đến thư mục của mô-đun đang gọi
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']904 [xem PEP 328 để biết chi tiết]
Khi biến tên có dạng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']933, thông thường, gói cấp cao nhất [tên cho đến dấu chấm đầu tiên] được trả về, không phải mô-đun được đặt tên theo tên. Tuy nhiên, khi một đối số từ danh sách không trống được đưa ra, mô-đun được đặt tên theo tên được trả về
Ví dụ: câu lệnh
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']934 dẫn đến mã byte giống như mã sau
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']1
Tuyên bố
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']935 dẫn đến cuộc gọi này
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']2
Lưu ý cách
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']904 trả về mô-đun cấp cao nhất ở đây vì đây là đối tượng được liên kết với một tên bằng câu lệnh
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']924
Mặt khác, tuyên bố
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']938 dẫn đến
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']3
Ở đây, mô-đun
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']939 được trả về từ
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']904. Từ đối tượng này, các tên cần nhập được lấy và gán cho tên tương ứng của chúng
Nếu bạn chỉ muốn nhập một mô-đun [có thể nằm trong một gói] theo tên, hãy sử dụng
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']923
Đã thay đổi trong phiên bản 3. 3. Các giá trị âm cho cấp độ không còn được hỗ trợ [điều này cũng thay đổi giá trị mặc định thành 0].
Đã thay đổi trong phiên bản 3. 9. Khi các tùy chọn dòng lệnh
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']942 hoặc
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']943 đang được sử dụng, biến môi trường
>>> format[14, '#b'], format[14, 'b'] ['0b1110', '1110'] >>> f'{14:#b}', f'{14:b}' ['0b1110', '1110']944 hiện bị bỏ qua.
chú thích
1Lưu ý rằng trình phân tích cú pháp chỉ chấp nhận quy ước cuối dòng kiểu Unix. Nếu bạn đang đọc mã từ một tệp, hãy đảm bảo sử dụng chế độ chuyển đổi dòng mới để chuyển đổi các dòng mới kiểu Windows hoặc Mac