search

Toán tử hải mã Python w3schools

1 năms trước
Trả lời: 0
Lượt xem: 121

Có cú pháp mới 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
6 gán giá trị cho các biến như một phần của biểu thức lớn hơn. Nó được gọi một cách trìu mến là "người điều hành hải mã" do giống với mắt và ngà của một con hải mã

Show

Trong ví dụ này, biểu thức gán giúp tránh gọi 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
7 hai lần

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

Một lợi ích tương tự phát sinh trong quá trình khớp biểu thức chính quy trong đó các đối tượng khớp được cần hai lần, một lần để kiểm tra xem có khớp hay không và một lần khác để trích xuất một nhóm con

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0

Toán tử cũng hữu ích với các vòng lặp while tính toán một giá trị để kiểm tra kết thúc vòng lặp và sau đó cần lại giá trị đó trong phần thân của vòng lặp

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)

Một trường hợp sử dụng thúc đẩy khác phát sinh trong việc hiểu danh sách trong đó một giá trị được tính toán trong điều kiện lọc cũng cần thiết trong nội dung biểu thức

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]

Cố gắng hạn chế sử dụng toán tử hải mã để làm sạch các trường hợp giúp giảm độ phức tạp và cải thiện khả năng đọc

Xem PEP 572 để biết mô tả đầy đủ

(Đóng góp bởi Emily Morehouse trong bpo-35224. )

Thông số chỉ vị trí¶

Có một cú pháp tham số chức năng mới 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
8 để chỉ ra rằng một số tham số chức năng phải được chỉ định theo vị trí và không thể được sử dụng làm đối số từ khóa. Đây là cùng một ký hiệu được hiển thị bởi 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
9 cho các hàm C được chú thích bằng công cụ Argument Clinic của Larry Hastings.

Trong ví dụ sau, tham số a và b chỉ là vị trí, trong khi c hoặc d có thể là vị trí hoặc từ khóa và e hoặc f bắt buộc phải là từ khóa

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

Sau đây là một cuộc gọi hợp lệ

f(10, 20, 30, d=40, e=50, f=60)

Tuy nhiên, đây là những cuộc gọi không hợp lệ

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
0

Một trường hợp sử dụng cho ký hiệu này là nó cho phép các hàm Python thuần túy mô phỏng đầy đủ các hành vi của các hàm được mã hóa C hiện có. Ví dụ: hàm 

f(10, 20, 30, d=40, e=50, f=60)
0 tích hợp không chấp nhận đối số từ khóa

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
2

Một trường hợp sử dụng khác là loại trừ đối số từ khóa khi tên tham số không hữu ích. Ví dụ: hàm dựng sẵn 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
7 có chữ ký 
f(10, 20, 30, d=40, e=50, f=60)
2. Điều này ngăn cản các cuộc gọi khó xử như

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
5

Một lợi ích khác của việc đánh dấu một tham số là chỉ vị trí là nó cho phép thay đổi tên tham số trong tương lai mà không có nguy cơ phá vỡ mã máy khách. Ví dụ: trong mô-đun 

f(10, 20, 30, d=40, e=50, f=60)
3, tên tham số dist có thể được thay đổi trong tương lai. Điều này đã được thực hiện với đặc tả chức năng sau

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
7

Vì các tham số ở bên trái của 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
8 không được hiển thị dưới dạng các từ khóa có thể, nên các tên tham số vẫn có sẵn để sử dụng trong 
f(10, 20, 30, d=40, e=50, f=60)
5

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
0

Điều này giúp đơn giản hóa rất nhiều việc triển khai các hàm và phương thức cần chấp nhận các đối số từ khóa tùy ý. Ví dụ: đây là một đoạn trích từ mã trong mô-đun 

f(10, 20, 30, d=40, e=50, f=60)
6

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
1

Xem PEP 570 để biết mô tả đầy đủ

(Đóng góp bởi Pablo Galindo trong bpo-36540. )

Bộ đệm hệ thống tệp song song cho các tệp bytecode đã biên dịch¶

Cài đặt 

f(10, 20, 30, d=40, e=50, f=60)
7 mới (cũng có sẵn dưới dạng 
f(10, 20, 30, d=40, e=50, f=60)
8 
f(10, 20, 30, d=40, e=50, f=60)
9) định cấu hình bộ đệm ẩn mã byte để sử dụng một cây hệ thống tệp song song riêng biệt, thay vì các thư mục con 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
00 mặc định trong mỗi thư mục nguồn

Vị trí của bộ đệm được báo cáo trong 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
01 (
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
02 cho biết vị trí mặc định trong thư mục con của 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
00)

(Đóng góp bởi Carl Meyer trong bpo-33499. )

Bản dựng gỡ lỗi sử dụng cùng một ABI như bản phát hành¶

Python hiện sử dụng cùng một ABI cho dù nó được tích hợp ở chế độ phát hành hay gỡ lỗi. Trên Unix, khi Python được xây dựng ở chế độ gỡ lỗi, giờ đây có thể tải các phần mở rộng C được xây dựng ở chế độ phát hành và các phần mở rộng C được xây dựng bằng ABI ổn định

Bản phát hành và bản dựng gỡ lỗi hiện tương thích với ABI. xác định macro 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
04 không còn ngụ ý macro 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
05, đưa ra sự không tương thích ABI duy nhất. Macro 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
05, bổ sung hàm 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
07 và biến môi trường 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
08, có thể được đặt bằng cách sử dụng tùy chọn bản dựng 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
09 mới. (Đóng góp bởi Victor Stinner trong bpo-36465. )

Trên Unix, các tiện ích mở rộng của C không còn được liên kết với libpython ngoại trừ trên Android và Cygwin. Hiện tại, Python được liên kết tĩnh có thể tải tiện ích mở rộng C được tạo bằng thư viện Python được chia sẻ. (Đóng góp bởi Victor Stinner trong bpo-21536. )

Trên Unix, khi Python được xây dựng ở chế độ gỡ lỗi, giờ đây, quá trình nhập cũng tìm kiếm các tiện ích mở rộng C được biên dịch trong chế độ phát hành và các tiện ích mở rộng C được biên dịch với ABI ổn định. (Đóng góp bởi Victor Stinner trong bpo-36722. )

Để nhúng Python vào một ứng dụng, một tùy chọn 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
20 mới phải được chuyển đến 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
21 để nhận được 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
22 (liên kết ứng dụng với libpython). Để hỗ trợ cả 3. 8 trở lên, hãy thử 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
21 trước và dự phòng thành 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
24 (không có 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
20) nếu lệnh trước đó không thành công

Thêm mô-đun pkg-config 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
26 để nhúng Python vào ứng dụng. 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
27 bao gồm 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
22. Để hỗ trợ cả 3. 8 trở lên, trước tiên hãy thử dùng 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
29 và dự phòng bằng 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
50 (không có 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
20) nếu lệnh trước đó không thành công (thay thế 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
52 bằng phiên bản Python)

Mặt khác, 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
53 không còn chứa 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
22. Tiện ích mở rộng C không được liên kết với libpython (ngoại trừ trên Android và Cygwin, các trường hợp của chúng được xử lý bởi tập lệnh); . (Đóng góp bởi Victor Stinner trong bpo-36721. )

f-strings hỗ trợ def f(a, b, /, c, d, *, e, f): print(a, b, c, d, e, f) 55 cho các biểu thức tự ghi lại và gỡ lỗi¶

Đã thêm trình xác định 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
55 vào f-string s. Một chuỗi f chẳng hạn như 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
57 sẽ mở rộng thành văn bản của biểu thức, một dấu bằng, sau đó là biểu diễn của biểu thức được đánh giá. Ví dụ. 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
2

Thông thường chỉ định định dạng chuỗi f cho phép kiểm soát nhiều hơn cách hiển thị kết quả của biểu thức. 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
3

Trình xác định 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
55 sẽ hiển thị toàn bộ biểu thức để có thể hiển thị các phép tính

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
4

(Đóng góp bởi Eric V. Smith và Larry Hastings trong bpo-36817. )

PEP 578. Móc kiểm tra thời gian chạy Python¶

PEP thêm một Audit Hook và Verified Open Hook. Cả hai đều có sẵn từ Python và mã gốc, cho phép các ứng dụng và khung được viết bằng mã Python thuần túy để tận dụng các thông báo bổ sung, đồng thời cho phép người nhúng hoặc quản trị viên hệ thống triển khai các bản dựng Python trong đó kiểm tra luôn được bật

Xem PEP 578 để biết đầy đủ chi tiết

PEP 587. Cấu hình khởi tạo Python¶

PEP 587 thêm API C mới để định cấu hình Khởi tạo Python cung cấp khả năng kiểm soát tốt hơn trên toàn bộ cấu hình và báo cáo lỗi tốt hơn

New structures

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    59

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    70

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    71

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    72

New functions

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    73

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    74

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    75

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    76

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    77

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    78

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    79

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    00

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    01

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    02

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    03

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    04

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    05

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    06

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    07

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    08

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    09

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    10

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    11

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    12

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    13

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    14

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    15

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    16

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    17

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    18

This PEP also adds 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
19 (
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
70 type) and 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
21 (
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
59 type) fields to these internal structures. 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
21 becomes the new reference configuration, replacing global configuration variables and other private variables

See Python Initialization Configuration for the documentation.

See PEP 587 for a full description

(Contributed by Victor Stinner in bpo-36763. )

PEP 590. Vectorcall. a fast calling protocol for CPython¶

The Vectorcall Protocol is added to the Python/C API. It is meant to formalize existing optimizations which were already done for various classes. Any static type implementing a callable can use this protocol.

Đây là tạm thời. Mục đích là làm cho nó hoàn toàn công khai trong Python 3. 9

Xem PEP 590 để biết mô tả đầy đủ

(Đóng góp bởi Jeroen Demeyer, Mark Shannon và Petr Viktorin trong bpo-36974. )

Pickle giao thức 5 với bộ đệm dữ liệu ngoài băng¶

Khi 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
24 được sử dụng để truyền dữ liệu lớn giữa các quy trình Python nhằm tận dụng lợi thế của quá trình xử lý đa lõi hoặc đa máy, điều quan trọng là phải tối ưu hóa quá trình truyền bằng cách giảm các bản sao bộ nhớ và có thể bằng cách áp dụng các kỹ thuật tùy chỉnh như nén phụ thuộc vào dữ liệu

Giao thức 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
24 5 giới thiệu hỗ trợ cho bộ đệm ngoài băng nơi dữ liệu tương thích với PEP 3118 có thể được truyền tách biệt khỏi luồng pickle chính, theo quyết định của lớp giao tiếp

Xem PEP 574 để biết mô tả đầy đủ

(Đóng góp bởi Antoine Pitrou trong bpo-36785. )

Thay đổi ngôn ngữ khác¶

  • Một câu lệnh 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    26 là bất hợp pháp trong mệnh đề 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    27 do có vấn đề với việc triển khai. Trong Trăn 3. 8 hạn chế này đã được dỡ bỏ. (Đóng góp bởi Serhiy Storchaka trong bpo-32489. )

  • Các loại 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    28, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    29 và 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    30 hiện có phương thức 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    31 giống như phương thức được tìm thấy trong 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    32 và 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    33. Tiện ích mở rộng API nhỏ này giúp bạn có thể viết 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    34 và để nó hoạt động trên nhiều loại số. (Đóng góp bởi Lisa Roach trong bpo-33073 và Raymond Hettinger trong bpo-37819. )

  • Các hàm tạo của 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    29, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    32 và 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    37 hiện sẽ sử dụng phương thức đặc biệt của 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    38, nếu có và phương thức tương ứng 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    39, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    40 hoặc 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    41 không có sẵn. (Đóng góp bởi Serhiy Storchaka trong bpo-20092. )

  • Đã thêm hỗ trợ của 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    42 thoát trong 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    43

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    5

    (Đóng góp bởi Jonathan Eunice và Serhiy Storchaka trong bpo-30688. )

  • Dict và dictviews hiện có thể lặp lại theo thứ tự chèn đảo ngược bằng cách sử dụng 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    44. (Đóng góp bởi Rémi Lapeyre trong bpo-33462. )

  • Cú pháp cho phép tên từ khóa trong lời gọi hàm bị hạn chế hơn nữa. Đặc biệt, 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    45 không còn được phép. Nó không bao giờ có ý định cho phép nhiều hơn một tên trần ở phía bên trái của thuật ngữ gán đối số từ khóa. (Đóng góp bởi Benjamin Peterson trong bpo-34641. )

  • Giải nén lặp lại tổng quát trong các câu lệnh 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    46 và 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    47 không còn yêu cầu dấu ngoặc đơn kèm theo. Điều này làm cho cú pháp năng suất và trả về phù hợp hơn với cú pháp gán thông thường

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    6

    (Đóng góp bởi David Cuthbert và Jordan Chapman trong bpo-32117. )

  • Khi một dấu phẩy bị thiếu trong mã chẳng hạn như 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    48, trình biên dịch sẽ hiển thị một 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    49 với một gợi ý hữu ích. Điều này cải thiện khi chỉ có một 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    50 chỉ ra rằng bộ dữ liệu đầu tiên không thể gọi được. (Đóng góp bởi Serhiy Storchaka trong bpo-15248. )

  • Các phép toán số học giữa các lớp con của các đối tượng 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    51 hoặc 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    52 và 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    53 hiện trả về một thể hiện của lớp con, thay vì lớp cơ sở. Điều này cũng ảnh hưởng đến loại hoạt động trả về mà việc triển khai (trực tiếp hoặc gián tiếp) sử dụng số học 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    53, chẳng hạn như 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    55. (Đóng góp bởi Paul Ganssle trong bpo-32417. )

  • Khi trình thông dịch Python bị gián đoạn bởi Ctrl-C (SIGINT) và kết quả là ngoại lệ 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    56 không bị bắt, quy trình Python hiện thoát qua tín hiệu SIGINT hoặc với mã thoát chính xác để quy trình gọi có thể phát hiện ra rằng nó đã chết do một . Shell trên POSIX và Windows sử dụng điều này để chấm dứt tập lệnh đúng cách trong các phiên tương tác. (Được đóng góp bởi Google thông qua Gregory P. Smith trong bpo-1054041. )

  • Một số kiểu lập trình nâng cao yêu cầu cập nhật đối tượng 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    57 cho một chức năng hiện có. Vì các đối tượng mã là bất biến, nên cần tạo một đối tượng mã mới, một đối tượng mã được mô hình hóa trên đối tượng mã hiện có. Với 19 tham số, điều này hơi tẻ nhạt. Bây giờ, phương pháp mới 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    58 cho phép tạo một bản sao với một vài tham số đã thay đổi

    Đây là một ví dụ thay đổi hàm 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    59 để ngăn tham số dữ liệu được sử dụng làm đối số từ khóa

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    7

    (Đóng góp bởi Victor Stinner trong bpo-37032. )

  • Đối với số nguyên, dạng ba đối số của hàm 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    60 hiện cho phép số mũ âm trong trường hợp cơ số tương đối nguyên tố với mô đun. Sau đó, nó tính toán nghịch đảo mô-đun với cơ số khi số mũ là 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    61 và lũy thừa phù hợp của nghịch đảo đó đối với các số mũ âm khác. Ví dụ: để tính nghịch đảo phép nhân theo mô-đun của 38 theo mô-đun 137, hãy viết

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    8

    Nghịch đảo mô-đun phát sinh trong giải pháp của phương trình Diophantine tuyến tính. Ví dụ: để tìm nghiệm số nguyên cho 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    62, trước tiên hãy viết lại thành 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    63 rồi giải

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    9

    (Đóng góp bởi Mark Dickinson trong bpo-36027. )

  • Khả năng hiểu chính tả đã được đồng bộ hóa với các chữ chính tả để khóa được tính trước và giá trị thứ hai

    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    0

    Thứ tự thực hiện được đảm bảo hữu ích với các biểu thức gán vì các biến được gán trong biểu thức chính sẽ có sẵn trong biểu thức giá trị

    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    1

    (Contributed by Jörn Heissler in bpo-35224. )

  • Phương thức 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    64 hiện có thể trả về một Tuple dài từ hai đến sáu phần tử. Formerly, five was the limit. The new, optional sixth element is a callable with a 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    65 signature. This allows the direct control over the state-updating behavior of a specific object. If not None, this callable will have priority over the object’s 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    66 method. (Contributed by Pierre Glaser and Olivier Grisel in bpo-35900. )

New Modules¶

  • The new 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    67 module provides (provisional) support for reading metadata from third-party packages. For example, it can extract an installed package’s version number, list of entry points, and more

    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    2

    (Contributed by Barry Warsaw and Jason R. Coombs in bpo-34632. )

Improved Modules¶

ast¶

AST nodes now have 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
68 and 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
69 attributes, which give the precise location of the end of the node. (This only applies to nodes that have 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
70 and 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
71 attributes. )

New function 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
72 returns the source code for a specific AST node

(Contributed by Ivan Levkivskyi in bpo-33416. )

The 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
73 function has some new flags

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    74 khiến nó trả về văn bản của các nhận xét loại PEP 484 và PEP 526 được liên kết với các nút AST nhất định;

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    75 can be used to parse PEP 484 “signature type comments” (returned for function definition AST nodes);

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    76 allows specifying an earlier Python 3 version. For example, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    77 will treat 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    78 and 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    79 as non-reserved words

(Contributed by Guido van Rossum in bpo-35766. )

asyncio¶

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
80 has graduated from the provisional to stable API. This function can be used to execute a coroutine and return the result while automatically managing the event loop. For example. 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
3

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

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
4

Việc triển khai thực tế phức tạp hơn nhiều. Thus, 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
80 should be the preferred way of running asyncio programs

(Contributed by Yury Selivanov in bpo-32314. )

Running 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
82 launches a natively async REPL. This allows rapid experimentation with code that has a top-level 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
79. There is no longer a need to directly call 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
80 which would spawn a new event loop on every invocation

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
5

(Contributed by Yury Selivanov in bpo-37028. )

The exception 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
85 now inherits from 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
86 rather than 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
87 and no longer inherits from 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
88. (Contributed by Yury Selivanov in bpo-32528. )

On Windows, the default event loop is now 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
89. (Contributed by Victor Stinner in bpo-34687. )

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
89 now also supports UDP. (Contributed by Adam Meily and Andrew Svetlov in bpo-29883. )

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
89 can now be interrupted by 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
56 (“CTRL+C”). (Đóng góp bởi Vladimir Matveev trong bpo-23057. )

Added 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
93 for getting the wrapped coroutine within an 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
94. (Contributed by Alex Grönholm in bpo-36999. )

Asyncio tasks can now be named, either by passing the 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
95 keyword argument to 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
96 or the 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
97 event loop method, or by calling the 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
98 method on the task object. The task name is visible in the 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
99 output of 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
94 and can also be retrieved using the 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
01 method. (Contributed by Alex Grönholm in bpo-34270. )

Added support for Happy Eyeballs to 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
02. To specify the behavior, two new parameters have been added. happy_eyeballs_delay and interleave. The Happy Eyeballs algorithm improves responsiveness in applications that support IPv4 and IPv6 by attempting to simultaneously connect using both. (Contributed by twisteroid ambassador in bpo-33530. )

builtins¶

The 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
03 built-in has been improved to accept the 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
04 flag. With this new flag passed, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
03 will allow top-level 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
79, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
07 and 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
08 constructs that are usually considered invalid syntax. Asynchronous code object marked with the 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
09 flag may then be returned. (Đóng góp bởi Matthias Bussonnier trong bpo-34616)

bộ sưu tập¶

The 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
10 method for 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
11 now returns a 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
12 instead of a 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
13. This works because regular dicts have guaranteed ordering since Python 3. 7. If the extra features of 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
14 are required, the suggested remediation is to cast the result to the desired type. 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
15. (Contributed by Raymond Hettinger in bpo-35864. )

cProfile¶

The 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
16 class can now be used as a context manager. Profile a block of code by running

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
6

(Contributed by Scott Sanderson in bpo-29235. )

csv¶

The 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
17 now returns instances of 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
12 instead of a 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
13. The tool is now faster and uses less memory while still preserving the field order. (Contributed by Michael Selik in bpo-34003. )

curses¶

Added a new variable holding structured version information for the underlying ncurses library. 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
20. (Contributed by Serhiy Storchaka in bpo-31680. )

ctypes¶

On Windows, 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
21 and subclasses now accept a winmode parameter to specify flags for the underlying 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
22 call. Các cờ mặc định được đặt để chỉ tải các phần phụ thuộc DLL từ các vị trí đáng tin cậy, bao gồm đường dẫn lưu trữ DLL (nếu đường dẫn đầy đủ hoặc một phần được sử dụng để tải DLL ban đầu) và các đường dẫn được thêm bởi 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
23. (Đóng góp bởi Steve Dower trong bpo-36085. )

ngày giờ¶

Đã thêm các hàm tạo thay thế mới 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
24 và 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
25, chúng tạo các đối tượng 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
26 và 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
27 tương ứng từ năm ISO, số tuần và ngày trong tuần; . (Đóng góp bởi Paul Ganssle trong bpo-36004. )

công cụ chức năng¶

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
29 hiện có thể được sử dụng như một công cụ trang trí thẳng thay vì là một hàm trả về một công cụ trang trí. Vì vậy, cả hai đều được hỗ trợ

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
7

(Đóng góp bởi Raymond Hettinger trong bpo-36772. )

Đã thêm trình trang trí 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
30 mới, dành cho các thuộc tính được tính toán được lưu trong bộ nhớ đệm cho vòng đời của phiên bản

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
8

(Đóng góp bởi Carl Meyer trong bpo-21145)

Đã thêm một trình trang trí 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
31 mới để chuyển đổi các phương thức thành các hàm chung bằng cách sử dụng một lần gửi:

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
9

(Đóng góp bởi Ethan Smith trong bpo-32380)

gc¶

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
32 hiện có thể nhận tham số tạo tùy chọn cho biết một thế hệ để lấy các đối tượng từ. (Đóng góp bởi Pablo Galindo trong bpo-36016. )

gettext¶

Đã thêm 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
33 và các biến thể của nó. (Được đóng góp bởi Franz Glasner, Éric Araujo và Cheryl Sabella trong bpo-2504. )

gzip¶

Đã thêm tham số mtime vào 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
34 cho đầu ra có thể lặp lại. (Đóng góp bởi Guo Ci Teo trong bpo-34898. )

Ngoại lệ 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
35 hiện được nâng lên thay vì 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
36 đối với một số loại tệp gzip không hợp lệ hoặc bị hỏng. (Đóng góp bởi Filip Gruszczyński, Michele Orrù, và Zackery Spytz trong bpo-6584. )

IDLE và idlib¶

Đầu ra trên N dòng (50 theo mặc định) được nén xuống một nút. Có thể thay đổi N trong phần PyShell của trang Chung của hộp thoại Cài đặt. Ít dòng hơn, nhưng có thể dài hơn, có thể được nén bằng cách nhấp chuột phải vào đầu ra. Đầu ra đã ép có thể được mở rộng tại chỗ bằng cách nhấp đúp vào nút hoặc vào khay nhớ tạm hoặc một cửa sổ riêng bằng cách nhấp chuột phải vào nút. (Đóng góp bởi Tal Einat trong bpo-1529353. )

Thêm “Chạy tùy chỉnh” vào menu Chạy để chạy mô-đun với cài đặt tùy chỉnh. Mọi đối số dòng lệnh đã nhập đều được thêm vào sys. argv. Chúng cũng xuất hiện lại trong hộp cho lần chạy tùy chỉnh tiếp theo. Người ta cũng có thể chặn khởi động lại mô-đun chính Shell bình thường. (Được đóng góp bởi Cheryl Sabella, Terry Jan Reedy và những người khác trong bpo-5680 và bpo-37627. )

Đã thêm số dòng tùy chọn cho cửa sổ trình chỉnh sửa IDLE. Windows mở mà không có số dòng trừ khi được đặt khác trong tab Chung của hộp thoại cấu hình. Số dòng cho một cửa sổ hiện có được hiển thị và ẩn trong menu Tùy chọn. (Đóng góp bởi Tal Einat và Saimadhav Heblikar trong bpo-17535. )

Mã hóa gốc của hệ điều hành hiện được sử dụng để chuyển đổi giữa các chuỗi Python và các đối tượng Tcl. Điều này cho phép IDLE hoạt động với biểu tượng cảm xúc và các ký tự không phải BMP khác. Những ký tự này có thể được hiển thị hoặc sao chép và dán vào hoặc từ khay nhớ tạm. Chuyển đổi chuỗi từ Tcl sang Python và ngược lại không bao giờ thất bại. (Nhiều người đã làm việc này trong tám năm nhưng vấn đề cuối cùng đã được giải quyết bởi Serhiy Storchaka trong bpo-13153. )

Mới trong 3. 8. 1

Thêm tùy chọn để tắt nhấp nháy con trỏ. (Đóng góp bởi Zackery Spytz trong bpo-4603. )

Phím thoát hiện đóng các cửa sổ hoàn thành IDLE. (Đóng góp bởi Johnny Najera trong bpo-38944. )

Những thay đổi ở trên đã được nhập vào 3. 7 bản phát hành bảo trì

Thêm từ khóa vào danh sách hoàn thành tên mô-đun. (Đóng góp bởi Terry J. Sậy trong bpo-37765. )

quan sát¶

Hàm 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
37 hiện có thể tìm chuỗi tài liệu cho 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
38 nếu thuộc tính đó là 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
12 trong đó các giá trị là chuỗi tài liệu. Điều này cung cấp các tùy chọn tài liệu tương tự như những gì chúng tôi đã có cho 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
40, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
41 và 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
42

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
0

(Đóng góp bởi Raymond Hettinger trong bpo-36326. )

io¶

Trong chế độ phát triển (

f(10, 20, 30, d=40, e=50, f=60)
8 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
44) và trong bản dựng gỡ lỗi , trình hoàn thiện 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
45 hiện ghi nhật ký ngoại lệ nếu phương thức 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
46 không thành công. Ngoại lệ được bỏ qua âm thầm theo mặc định trong bản dựng phát hành. (Đóng góp bởi Victor Stinner trong bpo-18748. )

itertools¶

Hàm 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
47 đã thêm một đối số từ khóa ban đầu tùy chọn để chỉ định giá trị ban đầu

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
1

(Đóng góp bởi Lisa Roach trong bpo-34659. )

json. dụng cụ¶

Thêm tùy chọn 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
48 để phân tích mọi dòng đầu vào thành một đối tượng JSON riêng biệt. (Đóng góp bởi Weipeng Hong trong bpo-31553. )

khai thác gỗ¶

Đã thêm một đối số từ khóa bắt buộc vào 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
49 Khi được đặt thành đúng, mọi trình xử lý hiện có được đính kèm với bộ ghi gốc sẽ bị xóa và đóng trước khi thực hiện cấu hình được chỉ định bởi các đối số khác

Điều này giải quyết một vấn đề lâu dài. Khi một trình ghi nhật ký hoặc basicConfig() đã được gọi, các lệnh gọi tiếp theo tới basicConfig() sẽ bị bỏ qua một cách âm thầm. Điều này gây khó khăn cho việc cập nhật, thử nghiệm hoặc hướng dẫn các tùy chọn cấu hình ghi nhật ký khác nhau bằng lời nhắc tương tác hoặc sổ ghi chép Jupyter

(Được đề xuất bởi Raymond Hettinger, được thực hiện bởi Dong-hee Na và được Vinay Sajip xem xét trong bpo-33897. )

môn Toán¶

Đã thêm chức năng mới 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
50 để tính toán khoảng cách Euclide giữa hai điểm. (Đóng góp bởi Raymond Hettinger trong bpo-33089. )

Đã mở rộng chức năng 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
51 để xử lý nhiều thứ nguyên. Trước đây, nó chỉ hỗ trợ trường hợp 2-D. (Đóng góp bởi Raymond Hettinger trong bpo-33089. )

Đã thêm chức năng mới, 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
52, làm chức năng tương tự cho 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
53 trả về tích của giá trị 'bắt đầu' (mặc định. 1) lần lặp lại các số

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
2

(Đóng góp bởi Pablo Galindo trong bpo-35606. )

Đã thêm hai hàm tổ hợp mới 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
54 và 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
55

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
3

(Được đóng góp bởi Yash Aggarwal, Keller Fuchs, Serhiy Storchaka và Raymond Hettinger trong bpo-37128, bpo-37178 và bpo-35431. )

Đã thêm chức năng mới 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
56 để tính căn bậc hai số nguyên chính xác mà không cần chuyển đổi sang dấu phẩy động. Hàm mới hỗ trợ các số nguyên lớn tùy ý. Nó nhanh hơn 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
57 nhưng chậm hơn 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
58

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
4

(Đóng góp bởi Mark Dickinson trong bpo-36887. )

Hàm 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
59 không còn chấp nhận các đối số không giống kiểu int. (Đóng góp bởi Pablo Galindo trong bpo-33083. )

mmap¶

Lớp 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
60 hiện có phương thức 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
61 để truy cập lệnh gọi hệ thống 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
61. (Đóng góp bởi Zackery Spytz trong bpo-32941. )

đa xử lý¶

Đã thêm mô-đun 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
63 mới. (Đóng góp bởi Davin Potts trong bpo-35813. )

Trên macOS, phương thức bắt đầu sinh sản hiện được sử dụng theo mặc định. (Đóng góp bởi Victor Stinner trong bpo-33725. )

os¶

Đã thêm chức năng mới 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
23 trên Windows để cung cấp các đường dẫn tìm kiếm bổ sung cho các phần phụ thuộc gốc khi nhập các mô-đun mở rộng hoặc tải DLL bằng cách sử dụng 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
65. (Đóng góp bởi Steve Dower trong bpo-36085. )

Một chức năng 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
66 mới đã được thêm vào để bọc toà nhà tòa nhà 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
67. (Đóng góp bởi Zackery Spytz và Christian Heimes trong bpo-26836. )

Trên Windows, phần lớn logic thủ công để xử lý các điểm phân tích lại (bao gồm các liên kết tượng trưng và các đường nối thư mục) đã được ủy quyền cho hệ điều hành. Cụ thể, giờ đây, 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
68 sẽ duyệt qua mọi thứ được hệ điều hành hỗ trợ, trong khi đó, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
69 sẽ chỉ mở các điểm phân tích lại được xác định là “tên thay thế” trong khi các điểm khác được mở như đối với 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
68. Trong mọi trường hợp, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
71 sẽ chỉ có 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
72 được đặt cho các liên kết tượng trưng chứ không phải các loại điểm lặp lại khác. Để xác định các loại điểm phân tích cú pháp khác, hãy kiểm tra thuộc tính 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
73 mới

Trên Windows, 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
74 hiện có thể đọc các liên kết thư mục. Lưu ý rằng 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
75 sẽ trả về 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
76 cho các liên kết thư mục và do đó, mã kiểm tra 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
77 trước tiên sẽ tiếp tục coi các liên kết là thư mục, trong khi mã xử lý lỗi từ 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
74 hiện có thể coi các liên kết là liên kết

(Đóng góp bởi Steve Dower trong bpo-37834. )

hệ điều hành. con đường¶

Các hàm 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
79 trả về kết quả boolean như 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
80, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
81, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
82, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
83, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
75 và 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
85 hiện trả về 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
76 thay vì tăng 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
87 hoặc các lớp con của nó 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
88 và 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
89 cho các đường dẫn chứa các ký tự hoặc byte không thể biểu diễn ở cấp độ hệ điều hành. (Đóng góp bởi Serhiy Storchaka trong bpo-33721. )

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
90 trên Windows hiện ưu tiên biến môi trường 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
91 và không sử dụng 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
92, thường không được đặt cho tài khoản người dùng thông thường. (Đóng góp bởi Anthony Sottile trong bpo-36264. )

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
82 trên Windows không còn trả về 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
94 cho một liên kết đến một thư mục không tồn tại

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
95 trên Windows hiện giải quyết các điểm phân tích lại, bao gồm các liên kết tượng trưng và các đường nối thư mục

(Đóng góp bởi Steve Dower trong bpo-37834. )

pathlib¶

Các phương thức 

# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
96 trả về kết quả boolean như 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
80, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
98, 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
99, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
00, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
01, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
02, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
03, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
04, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
05 hiện trả về 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
76 thay vì nâng cao 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
87 hoặc lớp con của nó 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
88 cho các đường dẫn chứa các ký tự không thể biểu diễn ở cấp độ hệ điều hành. (Đóng góp bởi Serhiy Storchaka trong bpo-33721. )

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
09 để tạo một liên kết cứng trỏ đến một đường dẫn. (Đóng góp bởi Joannah Nanjekye trong bpo-26978)

dưa chua¶

Các tiện ích mở rộng 

discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
24 phân lớp của 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
11 được tối ưu hóa cho C giờ đây có thể ghi đè logic chọn lọc của các hàm và lớp bằng cách xác định phương thức 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
12 đặc biệt. (Đóng góp bởi Pierre Glaser và Olivier Grisel trong bpo-35900. )

plistlib¶

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
13 mới và hỗ trợ cho phép đọc và ghi các plist nhị phân được mã hóa NSKeyedArchiver. (Đóng góp bởi Jon Janzen trong bpo-26707. )

pprint¶

Mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
14 đã thêm tham số sort_dicts vào một số chức năng. Theo mặc định, các chức năng đó tiếp tục sắp xếp từ điển trước khi hiển thị hoặc in. Tuy nhiên, nếu sort_dicts được đặt thành false, từ điển sẽ giữ nguyên thứ tự các phím được chèn. Điều này có thể hữu ích để so sánh với các đầu vào JSON trong quá trình gỡ lỗi

Ngoài ra, có một chức năng mới tiện lợi, 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
15 giống như 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
16 nhưng với sort_dicts mặc định là 
# Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
76

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
5

(Đóng góp bởi Rémi Lapeyre trong bpo-30670. )

py_compile¶

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
18 hiện hỗ trợ chế độ im lặng. (Đóng góp bởi Joannah Nanjekye trong bpo-22640. )

shlex¶

Hàm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
19 mới đóng vai trò nghịch đảo của 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
20. (Đóng góp bởi Bo Bayles trong bpo-32102. )

đóng cửa¶

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
21 hiện chấp nhận đối số từ khóa 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
22 mới. (Đóng góp bởi Josh Bronson trong bpo-20849. )

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
23 hiện mặc định là pax hiện đại (POSIX. 1-2001) cho các kho lưu trữ mới để cải thiện tính di động và tuân thủ tiêu chuẩn, kế thừa từ thay đổi tương ứng đối với mô-đun 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
24. (Đóng góp bởi C. A. M. Gerlach trong bpo-30661. )

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
25 trên Windows hiện loại bỏ các liên kết thư mục mà không cần xóa đệ quy nội dung của chúng trước. (Đóng góp bởi Steve Dower trong bpo-37834. )

ổ cắm¶

Đã thêm các chức năng thuận tiện của 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
26 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
27 để tự động hóa các tác vụ cần thiết thường liên quan khi tạo ổ cắm máy chủ, bao gồm chấp nhận cả kết nối IPv4 và IPv6 trên cùng một ổ cắm. (Đóng góp bởi Giampaolo Rodolà trong bpo-17561. )

Các chức năng 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
28, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
29 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
30 đã được triển khai trên Windows. (Đóng góp bởi Zackery Spytz trong bpo-37007. )

ssl¶

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
31 để bật và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
32 để khởi tạo TLS 1. 3 xác thực sau bắt tay. (Đóng góp bởi Christian Heimes trong bpo-34670. )

số liệu thống kê¶

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
33 dưới dạng biến thể dấu phẩy động, nhanh hơn của 
discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
59. (Đóng góp bởi Raymond Hettinger và Steven D'Aprano trong bpo-35904. )

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
35 (Đóng góp bởi Raymond Hettinger trong bpo-27181. )

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
36 trả về danh sách các giá trị phổ biến nhất. (Đóng góp bởi Raymond Hettinger trong bpo-35892. )

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
37 phân chia dữ liệu hoặc phân phối thành các khoảng có thể trang bị được (e. g. phần tư, deciles hoặc phần trăm). (Đóng góp bởi Raymond Hettinger trong bpo-36546. )

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
38, một công cụ để tạo và thao tác phân phối bình thường của một biến ngẫu nhiên. (Đóng góp bởi Raymond Hettinger trong bpo-36018. )

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
6

hệ thống¶

Thêm chức năng 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
39 mới có thể được ghi đè để kiểm soát cách xử lý "ngoại lệ không thể chấp nhận được". Nó được gọi khi một ngoại lệ xảy ra nhưng không có cách nào để Python xử lý nó. Ví dụ: khi một hàm hủy đưa ra một ngoại lệ hoặc trong quá trình thu gom rác (
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
40). (Đóng góp bởi Victor Stinner trong bpo-36829. )

tarfile¶

Mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
24 hiện mặc định là pax hiện đại (POSIX. 1-2001) cho các kho lưu trữ mới, thay vì định dạng dành riêng cho GNU trước đó. Điều này cải thiện tính di động đa nền tảng với mã hóa nhất quán (UTF-8) ở định dạng chuẩn hóa và có thể mở rộng, đồng thời mang lại một số lợi ích khác. (Đóng góp bởi C. A. M. Gerlach trong bpo-36268. )

luồng¶

Thêm một hàm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
42 mới xử lý ngoại lệ 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
43 chưa được phát hiện. Nó có thể được ghi đè để kiểm soát cách xử lý các ngoại lệ 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
43 chưa được phát hiện. (Đóng góp bởi Victor Stinner trong bpo-1230540. )

Thêm hàm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
45 mới và thuộc tính 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
46 vào lớp 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
47. Chúng trả về ID luồng tích phân riêng của luồng hiện tại được chỉ định bởi kernel. Tính năng này chỉ khả dụng trên một số nền tảng nhất định, xem 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
48 để biết thêm thông tin. (Đóng góp bởi Jake Tesler trong bpo-36084. )

token hóa¶

Mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
49 hiện ngầm phát ra mã thông báo 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
50 khi được cung cấp đầu vào không có dòng mới ở cuối. Hành vi này hiện khớp với những gì mã thông báo C thực hiện trong nội bộ. (Đóng góp bởi Ammar Askar trong bpo-33899. )

tkinter¶

Đã thêm các phương thức 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
51, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
52, 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
53 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
54 trong lớp 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
55. (Đóng góp bởi Juliette Monsel trong bpo-34829. )

Đã thêm phương thức 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
56 vào lớp 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
57. (Đóng góp bởi Juliette Monsel trong bpo-23831. )

Lớp 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
58 hiện có các phương thức 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
59 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
60. (Đóng góp bởi Zackery Spytz trong bpo-25451. )

thời gian¶

Đã thêm đồng hồ mới 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
61 cho macOS 10. 12. (Đóng góp bởi Joannah Nanjekye trong bpo-35702. )

đánh máy¶

Mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
62 kết hợp một số tính năng mới

  • Loại từ điển với các loại theo khóa. Xem PEP 589 và 

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    63. TypedDict chỉ sử dụng các phím chuỗi. Theo mặc định, mọi khóa được yêu cầu phải có mặt. Chỉ định “total=False” để cho phép các phím là tùy chọn

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    7

  • các loại chữ. Xem PEP 586 và 

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    64. Các loại chữ chỉ ra rằng một tham số hoặc giá trị trả về bị ràng buộc với một hoặc nhiều giá trị chữ cụ thể

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    8

  • Các biến, hàm, phương thức và lớp “cuối cùng”. Xem PEP 591, 

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    65 và 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    66. Vòng loại cuối cùng hướng dẫn trình kiểm tra kiểu tĩnh hạn chế phân lớp con, ghi đè hoặc gán lại

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    9

  • định nghĩa giao thức. Xem PEP 544, 

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    67 và 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    68. Các ABC đơn giản như 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    69 hiện là lớp con của 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    70

  • Lớp giao thức mới 

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    71

  • Chức năng mới 

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    72 và 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    73

unicodedata¶

Mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
74 đã được nâng cấp để sử dụng Unicode 12. 1. 0 phát hành

Chức năng mới 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
75 có thể được sử dụng để xác minh một chuỗi ở dạng bình thường cụ thể, thường nhanh hơn nhiều so với việc chuẩn hóa chuỗi thực sự. (Được đóng góp bởi Max Belanger, David Euresti và Greg Price trong bpo-32285 và bpo-37966)

đơn vị nhất¶

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
76 để hỗ trợ phiên bản không đồng bộ của 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
77. Các chức năng xác nhận mới phù hợp để thử nghiệm cũng đã được thêm vào. (Đóng góp bởi Lisa Roach trong bpo-26467)

Đã thêm 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
78 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
79 vào unittest để hỗ trợ dọn dẹp cho 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
80 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
81. (Đóng góp bởi Lisa Roach trong bpo-24412. )

Một số chức năng xác nhận giả hiện cũng in danh sách các cuộc gọi thực tế khi thất bại. (Đóng góp bởi Petter Strandmark trong bpo-35047. )

Mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
82 đã nhận được hỗ trợ cho các coroutine được sử dụng làm trường hợp thử nghiệm với 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
83. (Đóng góp bởi Andrew Svetlov trong bpo-32972. )

Ví dụ

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
0

venv¶

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
84 hiện bao gồm tập lệnh 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
85 trên tất cả các nền tảng để kích hoạt môi trường ảo trong PowerShell Core 6. 1. (Đóng góp bởi Brett Cannon trong bpo-32718. )

yếu tố¶

Các đối tượng proxy được trả về bởi 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
86 hiện hỗ trợ các toán tử nhân ma trận 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
87 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
88 ngoài các toán tử số khác. (Đóng góp bởi Mark Dickinson trong bpo-36669. )

xml¶

Để giảm thiểu DTD và truy xuất thực thể bên ngoài, các mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
89 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
90 không còn xử lý các thực thể bên ngoài theo mặc định. (Đóng góp bởi Christian Heimes trong bpo-17239. )

Các phương thức 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
91 trong mô-đun 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
92 hỗ trợ các tìm kiếm ký tự đại diện như 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
93 bỏ qua không gian tên và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
94 trả về tất cả các thẻ trong không gian tên đã cho. (Đóng góp bởi Stefan Behnel trong bpo-28238. )

Mô-đun 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
92 cung cấp chức năng mới 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
96 thực hiện C14N 2. 0. (Đóng góp bởi Stefan Behnel trong bpo-13611. )

Đối tượng đích của 

[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
97 có thể nhận các sự kiện khai báo không gian tên thông qua các phương thức gọi lại mới 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
98 và 
[clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
99. Ngoài ra, mục tiêu 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
00 có thể được định cấu hình để xử lý các sự kiện về nhận xét và hướng dẫn xử lý để đưa chúng vào cây được tạo. (Đóng góp bởi Stefan Behnel trong bpo-36676 và bpo-36673. )

xmlrpc¶

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
01 hiện hỗ trợ đối số từ khóa tiêu đề tùy chọn cho chuỗi tiêu đề HTTP được gửi với mỗi yêu cầu. Trong số những thứ khác, điều này cho phép nâng cấp từ xác thực cơ bản mặc định lên xác thực phiên nhanh hơn. (Đóng góp bởi Cédric Krier trong bpo-35153. )

Tối ưu hóa¶

  • Mô-đun 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    02 hiện có thể sử dụng chức năng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    03 trong một số trường hợp để có hiệu suất tốt hơn. Hiện tại, nó chỉ được sử dụng trên macOS và Linux (dùng glibc 2. 24 hoặc mới hơn) nếu tất cả các điều kiện này được đáp ứng

    • close_fds là sai;

    • tham số preexec_fn, pass_fds, cwd và start_new_session không được thiết lập;

    • đường dẫn thực thi chứa một thư mục

    (Đóng góp bởi Joannah Nanjekye và Victor Stinner trong bpo-35537. )

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    04, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    05, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    06, 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    21 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    08 sử dụng lệnh gọi tòa nhà “sao chép nhanh” dành riêng cho nền tảng trên Linux và macOS để sao chép tệp hiệu quả hơn. “sao chép nhanh” có nghĩa là hoạt động sao chép xảy ra trong nhân, tránh việc sử dụng bộ đệm không gian người dùng trong Python như trong “_______009”. Trên Windows, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    04 sử dụng kích thước bộ đệm mặc định lớn hơn (1 MiB thay vì 16 KiB) và một biến thể dựa trên 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    11 của 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    12 được sử dụng. Tốc độ sao chép tệp 512 MiB trong cùng một phân vùng là khoảng +26% trên Linux, +50% trên macOS và +40% trên Windows. Ngoài ra, tiêu thụ ít chu kỳ CPU hơn nhiều. Xem phần Hoạt động sao chép hiệu quả phụ thuộc vào nền tảng . (Đóng góp bởi Giampaolo Rodolà trong bpo-33671. )

  • [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    21 sử dụng chức năng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    14 và tất cả các chức năng sao chép tùy thuộc vào nó sử dụng các giá trị 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    68 được lưu trong bộ nhớ cache. Tốc độ sao chép một thư mục có 8000 tệp là khoảng +9% trên Linux, +20% trên Windows và +30% trên chia sẻ Windows SMB. Ngoài ra, số lượng cuộc gọi tòa nhà của 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    68 đã giảm 38%, khiến cho 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    21 đặc biệt nhanh hơn trên các hệ thống tệp mạng. (Đóng góp bởi Giampaolo Rodolà trong bpo-33695. )

  • Giao thức mặc định trong mô-đun 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    24 hiện là Giao thức 4, được giới thiệu lần đầu trong Python 3. 4. Nó cung cấp hiệu suất tốt hơn và kích thước nhỏ hơn so với Giao thức 3 có sẵn kể từ Python 3. 0

  • Removed one 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    19 member from 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    20. Tất cả các đối tượng được theo dõi bởi GC (e. g. kích thước tuple, list, dict) giảm 4 hoặc 8 byte. (Contributed by Inada Naoki in bpo-33597. )

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    21 hiện sử dụng 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    38 để giảm dung lượng bộ nhớ của nó. (Đóng góp bởi Wouter Bolsterlee và Tal Einat trong bpo-30977)

  • Cải thiện hiệu suất của 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    23 thêm 33%. Xử lý đối số được tối ưu hóa và thêm một đường dẫn nhanh cho trường hợp phổ biến của một chỉ mục số nguyên không âm duy nhất vào một bộ (là trường hợp sử dụng điển hình trong thư viện chuẩn). (Đóng góp bởi Raymond Hettinger trong bpo-35664. )

  • Tra cứu trường tăng tốc trong 

    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    11. Bây giờ chúng nhanh hơn gấp hai lần, khiến chúng trở thành dạng tra cứu biến thể hiện nhanh nhất trong Python. (Được đóng góp bởi Raymond Hettinger, Pablo Galindo, và Joe Jevnik, Serhiy Storchaka trong bpo-32492. )

  • Hàm tạo 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    25 không phân bổ tổng thể bộ đệm mục bên trong nếu đầu vào có thể lặp lại có độ dài đã biết (đầu vào thực hiện 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    26). Điều này làm cho danh sách được tạo trung bình nhỏ hơn 12%. (Đóng góp bởi Raymond Hettinger và Pablo Galindo trong bpo-33234. )

  • Nhân đôi tốc độ ghi biến lớp. Khi một thuộc tính non-dunder được cập nhật, sẽ có một cuộc gọi không cần thiết để cập nhật các vị trí. (Được đóng góp bởi Stefan Behnel, Pablo Galindo Salgado, Raymond Hettinger, Neil Schemenauer và Serhiy Storchaka trong bpo-36012. )

  • Giảm chi phí chuyển đổi đối số được truyền cho nhiều hàm và phương thức dựng sẵn. This sped up calling some simple builtin functions and methods up to 20–50%. (Contributed by Serhiy Storchaka in bpo-23867, bpo-35582 and bpo-36127. )

  • Hướng dẫn 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    27 hiện sử dụng cơ chế “bộ nhớ cache trên mỗi opcode” mới. Bây giờ nhanh hơn khoảng 40%. (Đóng góp bởi Yury Selivanov và Inada Naoki trong bpo-26219. )

Thay đổi về API Build và C¶

  • Mặc định 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    28 trở thành một chuỗi rỗng. cờ 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    29 cho pymalloc trở nên vô dụng (các bản dựng có và không có pymalloc đều tương thích với ABI) và do đó đã bị xóa. (Đóng góp bởi Victor Stinner trong bpo-36707. )

    Example of changes

    • Chỉ chương trình 

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      30 được cài đặt, chương trình 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      31 đã biến mất

    • Chỉ có tập lệnh 

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      32 được cài đặt, tập lệnh 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      33 đã biến mất

    • Cờ 

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      29 đã bị xóa khỏi hậu tố của tên tệp thư viện động. các mô-đun mở rộng trong thư viện tiêu chuẩn cũng như các mô-đun được sản xuất và cài đặt bởi các gói của bên thứ ba, chẳng hạn như các mô-đun được tải xuống từ PyPI. Ví dụ, trên Linux, Python 3. 7 hậu tố 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      35 trở thành 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      36 trong Python 3. 8

  • Các tệp tiêu đề đã được sắp xếp lại để phân tách tốt hơn các loại API khác nhau

    • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      37 phải là API C ổn định công cộng di động

    • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      38 phải là API C không ổn định dành riêng cho CPython; 

    • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      41 is the private internal C API very specific to CPython. API này không đi kèm với bảo hành tương thích ngược và không được sử dụng bên ngoài CPython. Nó chỉ được hiển thị cho các nhu cầu rất cụ thể như trình gỡ lỗi và cấu hình phải truy cập vào các phần bên trong CPython mà không cần gọi các chức năng. API này hiện được cài đặt bởi 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      42

    (Đóng góp bởi Victor Stinner trong bpo-35134 và bpo-35081, công việc do Eric Snow khởi xướng trong Python 3. 7. )

  • Some macros have been converted to static inline functions. các loại tham số và loại trả về được xác định rõ ràng, chúng không có vấn đề cụ thể đối với macro, các biến có phạm vi cục bộ. ví dụ

    • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      43, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      44

    • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      45, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      46

    • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      47, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      48

    • chức năng riêng tư. 

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      49, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      50, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      51

    (Đóng góp bởi Victor Stinner trong bpo-35059. )

  • Hàm 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    52 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    53 đã bị xóa. Họ không làm gì kể từ Python 2. 7. 4 và Trăn 3. 2. 0, were excluded from the limited API (stable ABI), and were not documented. (Đóng góp bởi Victor Stinner trong bpo-35713. )

  • Kết quả của 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    54 bây giờ là loại 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    55 thay vì 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    56. (Đóng góp bởi Serhiy Storchaka trong bpo-33818. )

  • Tính hai mặt của 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    57 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    58 đã bị loại bỏ. Trước đây, khi cập nhật cây nguồn CPython, người ta phải sao chép thủ công 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    57 (bên trong cây nguồn) sang 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    58 (bên trong cây xây dựng) để phản ánh mọi thay đổi ngược dòng. Đây là một lợi ích nhỏ đối với các nhà đóng gói nhưng lại gây khó chịu thường xuyên cho các nhà phát triển sau quá trình phát triển CPython, vì việc quên sao chép tệp có thể gây ra lỗi xây dựng

    Bây giờ hệ thống xây dựng luôn đọc từ 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    58 bên trong cây nguồn. Những người muốn tùy chỉnh tệp đó được khuyến khích duy trì các thay đổi của họ trong git fork của CPython hoặc dưới dạng tệp vá, như họ sẽ làm đối với bất kỳ thay đổi nào khác đối với cây nguồn

    (Đóng góp bởi Antoine Pitrou trong bpo-32430. )

  • Các hàm chuyển đổi số Python thành số nguyên C như 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    62 và các hàm phân tích cú pháp đối số như 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    63 với các đơn vị định dạng chuyển đổi số nguyên như 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    64 hiện sẽ sử dụng phương thức đặc biệt 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    38 thay vì 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    39, nếu có. Cảnh báo không dùng nữa sẽ được phát ra đối với các đối tượng có phương thức 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    39 nhưng không có phương thức 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    38 (như 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    69 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    70). 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    71 bây giờ sẽ trả về 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    72 cho các đối tượng triển khai 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    38. 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    74, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    75 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    76 hiện cũng sử dụng phương pháp 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    38 nếu có. (Đóng góp bởi Serhiy Storchaka trong bpo-36048 và bpo-20092. )

  • Các đối tượng loại được cấp phát heap giờ đây sẽ tăng số lượng tham chiếu của chúng trong 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    78 (và macro song song của nó là 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    79) thay vì trong 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    80. Các loại sửa đổi phân bổ cá thể hoặc phân bổ có thể cần phải được điều chỉnh. (Đóng góp bởi Eddie Elizondo trong bpo-35810. )

  • Hàm mới 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    81 cho phép tạo các đối tượng mã như 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    82, nhưng có thêm tham số posonlyargcount để chỉ ra số lượng đối số chỉ vị trí. (Đóng góp bởi Pablo Galindo trong bpo-37221. )

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    83 hiện đặt 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    84 thành đường dẫn đầy đủ của chương trình (
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    85) thay vì tên chương trình (
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    86). (Đóng góp bởi Victor Stinner trong bpo-38234. )

Không dùng nữa¶

  • Lệnh distutils 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    87 hiện không được dùng nữa, thay vào đó hãy sử dụng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    88 (gói bánh xe). (Đóng góp bởi Victor Stinner trong bpo-37481. )

  • Các phương pháp không dùng nữa 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    89 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    90 trong mô-đun 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    91 hiện phát ra một 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    92 thay vì 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    93. Chúng sẽ bị xóa trong Python 3. 9. (Đóng góp bởi Serhiy Storchaka trong bpo-29209. )

  • Việc chuyển một đối tượng không phải là phiên bản của 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    94 sang 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    95 không được chấp nhận và sẽ bị cấm trong Python 3. 9. (Đóng góp bởi Elvis Pranskevichus trong bpo-34075. )

  • Các phương pháp 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    96 của 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    97, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    98 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    99 đã không còn được dùng nữa

    Việc triển khai các phương thức này đã bỏ qua tham số chỉ mục của chúng và thay vào đó trả về mục tiếp theo. (Đóng góp bởi Berker Peksag trong bpo-9372. )

  • Lớp 

    f(10, 20, 30, d=40, e=50, f=60)
    00 đã loại bỏ thuộc tính 
    f(10, 20, 30, d=40, e=50, f=60)
    01 bằng thuộc tính 
    f(10, 20, 30, d=40, e=50, f=60)
    02 có cùng thông tin. (Đóng góp bởi Raymond Hettinger trong bpo-36320. )

  • Các lớp 

    f(10, 20, 30, d=40, e=50, f=60)
    03 
    f(10, 20, 30, d=40, e=50, f=60)
    04, 
    f(10, 20, 30, d=40, e=50, f=60)
    05, 
    f(10, 20, 30, d=40, e=50, f=60)
    06, 
    f(10, 20, 30, d=40, e=50, f=60)
    07 và 
    f(10, 20, 30, d=40, e=50, f=60)
    08 được coi là không dùng nữa và sẽ bị xóa trong các phiên bản Python trong tương lai. 
    f(10, 20, 30, d=40, e=50, f=60)
    09 nên được sử dụng thay thế. (Đóng góp bởi Serhiy Storchaka trong bpo-32892. )

  • Các phương thức 

    f(10, 20, 30, d=40, e=50, f=60)
    10 
    f(10, 20, 30, d=40, e=50, f=60)
    11, 
    f(10, 20, 30, d=40, e=50, f=60)
    12, 
    f(10, 20, 30, d=40, e=50, f=60)
    13, 
    f(10, 20, 30, d=40, e=50, f=60)
    14 và 
    f(10, 20, 30, d=40, e=50, f=60)
    15 hiện không được dùng nữa và sẽ không được gọi trong các phiên bản Python trong tương lai. Thêm phương thức 
    f(10, 20, 30, d=40, e=50, f=60)
    16 để xử lý tất cả các nút không đổi. (Đóng góp bởi Serhiy Storchaka trong bpo-36917. )

  • Trình trang trí 

    f(10, 20, 30, d=40, e=50, f=60)
    17 decorator không được dùng nữa và sẽ bị xóa trong phiên bản 3. 10. Thay vì 
    f(10, 20, 30, d=40, e=50, f=60)
    18, hãy sử dụng 
    f(10, 20, 30, d=40, e=50, f=60)
    19. (Đóng góp bởi Andrew Svetlov trong bpo-36921. )

  • Trong 

    f(10, 20, 30, d=40, e=50, f=60)
    20, việc truyền rõ ràng đối số vòng lặp không được dùng nữa và sẽ bị xóa trong phiên bản 3. 10 cho những điều sau đây. 
    f(10, 20, 30, d=40, e=50, f=60)
    21, 
    f(10, 20, 30, d=40, e=50, f=60)
    22, 
    f(10, 20, 30, d=40, e=50, f=60)
    23, 
    f(10, 20, 30, d=40, e=50, f=60)
    24, 
    f(10, 20, 30, d=40, e=50, f=60)
    25, 
    f(10, 20, 30, d=40, e=50, f=60)
    26, 
    f(10, 20, 30, d=40, e=50, f=60)
    28, 
    f(10, 20, 30, d=40, e=50, f=60)
    29, 
    f(10, 20, 30, d=40, e=50, f=60)
    30, 
    f(10, 20, 30, d=40, e=50, f=60)
    31, 
    f(10, 20, 30, d=40, e=50, f=60)
    32, 
    f(10, 20, 30, d=40, e=50, f=60)
    33, 
    f(10, 20, 30, d=40, e=50, f=60)
    34, và 
    f(10, 20, 30, d=40, e=50, f=60)
    35

  • Việc chuyển rõ ràng các đối tượng coroutine sang 

    f(10, 20, 30, d=40, e=50, f=60)
    25 không được dùng nữa và sẽ bị xóa trong phiên bản 3. 11. (Đóng góp bởi Yury Selivanov trong bpo-34790. )

  • Các hàm và phương thức sau không được dùng trong mô-đun 

    f(10, 20, 30, d=40, e=50, f=60)
    37. 
    f(10, 20, 30, d=40, e=50, f=60)
    38, 
    f(10, 20, 30, d=40, e=50, f=60)
    39, 
    f(10, 20, 30, d=40, e=50, f=60)
    40 và 
    f(10, 20, 30, d=40, e=50, f=60)
    41. Chúng trả về các byte được mã hóa và có thể bạn sẽ nhận được các ngoại lệ không mong muốn liên quan đến Unicode nếu có vấn đề về mã hóa với các chuỗi đã dịch. Sẽ tốt hơn nhiều nếu sử dụng các giải pháp thay thế trả về chuỗi Unicode trong Python 3. Các chức năng này đã bị hỏng trong một thời gian dài

    Hàm 

    f(10, 20, 30, d=40, e=50, f=60)
    42, các phương thức 
    f(10, 20, 30, d=40, e=50, f=60)
    43 và 
    f(10, 20, 30, d=40, e=50, f=60)
    44 và tham số bộ mã của các hàm 
    f(10, 20, 30, d=40, e=50, f=60)
    45 và 
    f(10, 20, 30, d=40, e=50, f=60)
    46 cũng không được dùng nữa vì chúng chỉ được sử dụng cho các hàm 
    f(10, 20, 30, d=40, e=50, f=60)
    47. (Đóng góp bởi Serhiy Storchaka trong bpo-33710. )

  • Phương pháp 

    f(10, 20, 30, d=40, e=50, f=60)
    48 của 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    47 không được dùng nữa. (Đóng góp bởi Dong-hee Na trong bpo-35283. )

  • Nhiều hàm dựng sẵn và hàm mở rộng nhận các đối số số nguyên giờ đây sẽ phát ra cảnh báo không dùng nữa cho các 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    69, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    70 và bất kỳ đối tượng nào khác có thể được chuyển đổi thành số nguyên chỉ khi bị mất (e. g. có phương thức 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    39 nhưng không có phương thức 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    38). Trong phiên bản tương lai, chúng sẽ bị lỗi. (Đóng góp bởi Serhiy Storchaka trong bpo-36048. )

  • Không dùng nữa việc chuyển các đối số sau dưới dạng đối số từ khóa

    • func trong 

      f(10, 20, 30, d=40, e=50, f=60)
      54, 
      f(10, 20, 30, d=40, e=50, f=60)
      55, 
      f(10, 20, 30, d=40, e=50, f=60)
      56, 
      f(10, 20, 30, d=40, e=50, f=60)
      57, 
      f(10, 20, 30, d=40, e=50, f=60)
      58, 
      f(10, 20, 30, d=40, e=50, f=60)
      59 và 
      f(10, 20, 30, d=40, e=50, f=60)
      60

    • chức năng trong 

      f(10, 20, 30, d=40, e=50, f=60)
      61

    • fn theo phương thức 

      f(10, 20, 30, d=40, e=50, f=60)
      62 của 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      94 và 
      f(10, 20, 30, d=40, e=50, f=60)
      64

    • gọi lại trong 

      f(10, 20, 30, d=40, e=50, f=60)
      65, 
      f(10, 20, 30, d=40, e=50, f=60)
      66 và 
      f(10, 20, 30, d=40, e=50, f=60)
      67

    • c và typeid theo phương pháp 

      f(10, 20, 30, d=40, e=50, f=60)
      68 của 
      f(10, 20, 30, d=40, e=50, f=60)
      69 và 
      f(10, 20, 30, d=40, e=50, f=60)
      70

    • obj in 

      f(10, 20, 30, d=40, e=50, f=60)
      55

    Trong các bản phát hành Python trong tương lai, chúng sẽ chỉ dành cho vị trí . (Contributed by Serhiy Storchaka in bpo-36492. )

Loại bỏ API và tính năng¶

The following features and APIs have been removed from Python 3. 8

  • Bắt đầu với Python 3. 3, việc nhập ABC từ 

    f(10, 20, 30, d=40, e=50, f=60)
    6 không được dùng nữa và việc nhập phải được thực hiện từ 
    f(10, 20, 30, d=40, e=50, f=60)
    73. Being able to import from collections was marked for removal in 3. 8, nhưng đã bị trì hoãn đến 3. 9. (Xem bpo-36952. )

  • Mô-đun 

    f(10, 20, 30, d=40, e=50, f=60)
    74, không được dùng trong Python 3. 7, đã bị xóa. (Đóng góp bởi Victor Stinner trong bpo-35471. )

  • Hàm 

    f(10, 20, 30, d=40, e=50, f=60)
    75 đã bị xóa, sau khi không được dùng nữa kể từ Python 3. 3. sử dụng 
    f(10, 20, 30, d=40, e=50, f=60)
    76 thay thế. (Contributed by Victor Stinner in bpo-35345. )

  • Hàm 

    f(10, 20, 30, d=40, e=50, f=60)
    77 đã bị xóa, sau khi không được dùng nữa kể từ Python 3. 3. thay vào đó, hãy sử dụng 
    f(10, 20, 30, d=40, e=50, f=60)
    78 hoặc 
    f(10, 20, 30, d=40, e=50, f=60)
    79, tùy thuộc vào yêu cầu của bạn, để có hành vi được xác định rõ. (Đóng góp bởi Matthias Bussonnier trong bpo-36895. )

  • Tập lệnh 

    f(10, 20, 30, d=40, e=50, f=60)
    80 đã bị xóa để thay thế bằng 
    f(10, 20, 30, d=40, e=50, f=60)
    81 để giúp loại bỏ sự nhầm lẫn về trình thông dịch Python mà tập lệnh 
    f(10, 20, 30, d=40, e=50, f=60)
    80 được liên kết với. (Đóng góp bởi Brett Cannon trong bpo-25427. )

  • f(10, 20, 30, d=40, e=50, f=60)
    83, 
    f(10, 20, 30, d=40, e=50, f=60)
    84 và 
    f(10, 20, 30, d=40, e=50, f=60)
    85 bị xóa khỏi mô-đun 
    f(10, 20, 30, d=40, e=50, f=60)
    86. Chúng không được dùng nữa trong Python 3. 2 tuổi trở lên. Thay vào đó, chúng nên được nhập từ các mô-đun 
    f(10, 20, 30, d=40, e=50, f=60)
    87 và 
    f(10, 20, 30, d=40, e=50, f=60)
    88

  • Hàm 

    f(10, 20, 30, d=40, e=50, f=60)
    89 bị xóa khỏi mô-đun 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    24. Nó không được ghi lại và không dùng nữa kể từ Python 3. 3

  • Constructor 

    f(10, 20, 30, d=40, e=50, f=60)
    91 không còn chấp nhận đối số html. Nó không bao giờ có tác dụng và không được dùng nữa trong Python 3. 4. Tất cả các tham số khác hiện tại chỉ từ khóa . (Đóng góp bởi Serhiy Storchaka trong bpo-29209. )

  • Đã xóa phương pháp 

    f(10, 20, 30, d=40, e=50, f=60)
    92 của 
    f(10, 20, 30, d=40, e=50, f=60)
    91. (Contributed by Serhiy Storchaka in bpo-29209. )

  • bộ giải mã "unicode_internal" đã bị xóa. (Contributed by Inada Naoki in bpo-36297. )

  • Các đối tượng 

    f(10, 20, 30, d=40, e=50, f=60)
    94 và 
    f(10, 20, 30, d=40, e=50, f=60)
    95 của mô-đun 
    f(10, 20, 30, d=40, e=50, f=60)
    96 không được hiển thị cho người dùng. (Contributed by Aviv Palivoda in bpo-30262. )

  • Đối số từ khóa 

    f(10, 20, 30, d=40, e=50, f=60)
    97 của 
    f(10, 20, 30, d=40, e=50, f=60)
    98 và 
    f(10, 20, 30, d=40, e=50, f=60)
    99 đã bị bỏ qua và không dùng nữa kể từ Python 3. 6 đã được gỡ bỏ. bpo-36952 (Đóng góp bởi Matthias Bussonnier. )

  • Các hàm 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    000 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    001 không dùng nữa trong Python 3. 7 đã được gỡ bỏ; . )

Chuyển sang Python 3. số 8¶

This section lists previously described changes and other bugfixes that may require changes to your code

Thay đổi trong hành vi Python¶

  • Yield expressions (both 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    46 and 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    003 clauses) are now disallowed in comprehensions and generator expressions (aside from the iterable expression in the leftmost 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    004 clause). (Đóng góp bởi Serhiy Storchaka trong bpo-10544. )

  • Trình biên dịch hiện tạo ra một 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    49 khi kiểm tra danh tính (
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    006 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    007) được sử dụng với một số loại chữ nhất định (e. g. chuỗi, số). These can often work by accident in CPython, but are not guaranteed by the language spec. Cảnh báo khuyên người dùng nên sử dụng các bài kiểm tra đẳng thức (
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    008 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    009) để thay thế. (Đóng góp bởi Serhiy Storchaka trong bpo-34850. )

  • Trình thông dịch CPython có thể nuốt ngoại lệ trong một số trường hợp. In Python 3. 8 this happens in fewer cases. Đặc biệt, các ngoại lệ được nêu ra khi lấy thuộc tính từ từ điển loại không còn bị bỏ qua. (Đóng góp bởi Serhiy Storchaka trong bpo-35459. )

  • Đã xóa các triển khai 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    010 khỏi các kiểu dựng sẵn 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    28, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    29, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    32, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    37 và một số lớp khỏi thư viện chuẩn. Bây giờ họ kế thừa 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    015 từ 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    016. Kết quả là, việc định nghĩa phương thức 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    017 trong lớp con của các lớp này sẽ ảnh hưởng đến biểu diễn chuỗi của chúng. (Đóng góp bởi Serhiy Storchaka trong bpo-36793. )

  • Trên AIX, 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    018 không chứa phiên bản chính nữa. Nó luôn là 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    019, thay vì 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    020. 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    021. Vì các phiên bản Python cũ hơn bao gồm số phiên bản, do đó, bạn nên luôn sử dụng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    022. (Contributed by M. Cảm thấy trong bpo-36588. )

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    023 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    024 hiện kết thúc luồng hiện tại nếu được gọi trong khi trình thông dịch đang hoàn thiện, làm cho chúng nhất quán với 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    025, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    026 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    027. If this behavior is not desired, guard the call by checking 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    028 or 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    029. (Đóng góp bởi Joannah Nanjekye trong bpo-36475. )

Các thay đổi trong API Python¶

  • Hàm 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    030 hiện sử dụng mã hóa UTF-8 trên Windows, thay vì trang mã ANSI. xem PEP 529 để biết lý do. Chức năng này không còn được dùng nữa trên Windows. (Đóng góp bởi Victor Stinner trong bpo-37412. )

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    031 hiện có thể sử dụng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    03 trong một số trường hợp để có hiệu suất tốt hơn. Trên Hệ thống con Windows dành cho Linux và Mô phỏng người dùng QEMU, hàm tạo 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    033 sử dụng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    03 không còn đưa ra ngoại lệ đối với các lỗi như “chương trình bị thiếu”. Thay vào đó, tiến trình con không thành công với giá trị khác 0 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    035. (Đóng góp bởi Joannah Nanjekye và Victor Stinner trong bpo-35537. )

  • The preexec_fn argument of * 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    031 is no longer compatible with subinterpreters. The use of the parameter in a subinterpreter now raises 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    037. (Đóng góp bởi Eric Snow trong bpo-34651, được Christian Heimes sửa đổi trong bpo-37951. )

  • The 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    038 method no longer silently ignores arbitrary exceptions. (Đóng góp bởi Victor Stinner trong bpo-36348. )

  • Hàm 

    f(10, 20, 30, d=40, e=50, f=60)
    75 đã bị xóa, sau khi không được dùng nữa kể từ Python 3. 3. sử dụng 
    f(10, 20, 30, d=40, e=50, f=60)
    76 thay thế. (Contributed by Victor Stinner in bpo-35345. )

  • Hàm 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    041 không còn đưa ra ngoại lệ khi được cung cấp dữ liệu đa phương thức. Thay vào đó, nó trả về chế độ đầu tiên gặp phải trong dữ liệu đầu vào. (Contributed by Raymond Hettinger in bpo-35892. )

  • Phương thức 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    042 của lớp 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    043 không còn nhận đối số. Sử dụng nó với các đối số để thay đổi lựa chọn không được dùng trong Python 3. 6. Sử dụng các phương pháp chuyên dụng như 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    044 để thay đổi lựa chọn. (Contributed by Serhiy Storchaka in bpo-31508. )

  • Các phương thức 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    045, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    046 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    047 của 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    89 và phương thức 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    049 của 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    050, hiện giữ nguyên thứ tự thuộc tính do người dùng chỉ định. (Đóng góp bởi Diego Rojas và Raymond Hettinger trong bpo-34160. )

  • Cơ sở dữ liệu 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    051 được mở bằng cờ 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    052 hiện ở chế độ chỉ đọc. 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    053 với các cờ 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    052 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    055 không còn tạo cơ sở dữ liệu nếu nó không tồn tại. (Đóng góp bởi Serhiy Storchaka trong bpo-32749. )

  • Phương thức 

    f(10, 20, 30, d=40, e=50, f=60)
    92 được định nghĩa trong lớp con của 
    f(10, 20, 30, d=40, e=50, f=60)
    91 sẽ không còn được gọi nữa và sẽ phát ra một 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    058 thay vì một 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    92. Xác định phương thức 
    f(10, 20, 30, d=40, e=50, f=60)
    92 trên mục tiêu để xử lý khai báo loại tài liệu XML. (Contributed by Serhiy Storchaka in bpo-29209. )

  • Một 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    037 hiện được nâng lên khi siêu dữ liệu tùy chỉnh không cung cấp mục nhập 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    062 trong không gian tên được chuyển đến 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    063. Một 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    92 đã được phát ra trong Python 3. 6–3. 7. (Đóng góp bởi Serhiy Storchaka trong bpo-23722. )

  • Lớp 

    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    16 hiện có thể được sử dụng làm trình quản lý ngữ cảnh. (Đóng góp bởi Scott Sanderson trong bpo-29235. )

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    04, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    05, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    06, 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    21 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    08 sử dụng lệnh gọi tòa nhà “sao chép nhanh” dành riêng cho nền tảng (xem Hoạt động sao chép hiệu quả phụ thuộc vào nền tảng .

  • Kích thước bộ đệm mặc định của 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    04 trên Windows đã được thay đổi từ 16 KiB thành 1 MiB

  • Cấu trúc 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    20 đã thay đổi hoàn toàn. Tất cả mã đã chạm vào thành viên cấu trúc phải được viết lại. (See bpo-33597. )

  • Cấu trúc 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    073 đã được chuyển vào các tệp tiêu đề “nội bộ” (cụ thể là Bao gồm/nội bộ/pycore_pystate. h). Một 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    073 không rõ ràng vẫn có sẵn như một phần của API công khai (và ABI ổn định). Các tài liệu chỉ ra rằng không có trường nào của cấu trúc là công khai, vì vậy chúng tôi hy vọng không có ai sử dụng chúng. Tuy nhiên, nếu bạn dựa vào một hoặc nhiều trường riêng tư đó và không có lựa chọn nào khác thì vui lòng mở vấn đề BPO. We’ll work on helping you adjust (possibly including adding accessor functions to the public API). (Xem bpo-35886. )

  • The 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    075 method now returns 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    02 on success and raises an exception on error under all platforms. Trước đây, hành vi của nó phụ thuộc vào nền tảng. một giá trị khác không được trả về khi thành công; . Giá trị 0 được trả về khi thành công; . (Đóng góp bởi Berker Peksag trong bpo-2122. )

  • Các mô-đun 

    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    89 và 
    [clean_name.title() for name in names
 if (clean_name := normalize('NFC', name)) in allowed_names]
    90 không còn xử lý các thực thể bên ngoài theo mặc định. (Đóng góp bởi Christian Heimes trong bpo-17239. )

  • Xóa khóa khỏi cơ sở dữ liệu 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    079 chỉ đọc (
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    051, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    081 hoặc 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    082) tăng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    083 (
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    084, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    085 hoặc 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    086) thay vì 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    087. (Contributed by Xiang Zhang in bpo-33106. )

  • Simplified AST for literals. Tất cả các hằng số sẽ được biểu diễn dưới dạng phiên bản 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    088. Khởi tạo các lớp cũ 
    f(10, 20, 30, d=40, e=50, f=60)
    04, 
    f(10, 20, 30, d=40, e=50, f=60)
    05, 
    f(10, 20, 30, d=40, e=50, f=60)
    06, 
    f(10, 20, 30, d=40, e=50, f=60)
    07 và 
    f(10, 20, 30, d=40, e=50, f=60)
    08 sẽ trả về một thể hiện của 
    f(10, 20, 30, d=40, e=50, f=60)
    09. (Đóng góp bởi Serhiy Storchaka trong bpo-32892. )

  • # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    90 trên Windows hiện ưu tiên biến môi trường 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    91 và không sử dụng 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    92, thường không được đặt cho tài khoản người dùng thông thường. (Đóng góp bởi Anthony Sottile trong bpo-36264. )

  • The exception 

    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    85 now inherits from 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    86 rather than 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    87 and no longer inherits from 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    88. (Contributed by Yury Selivanov in bpo-32528. )

  • Chức năng 

    f(10, 20, 30, d=40, e=50, f=60)
    24 hiện chờ hủy chính xác khi sử dụng phiên bản của 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    94. Trước đây, khi hết thời gian chờ, nó đã bị hủy và ngay lập tức được trả lại. (Đóng góp bởi Elvis Pranskevichus trong bpo-32751. )

  • Hàm 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    204 hiện trả về một đối tượng ổ cắm an toàn để sử dụng khi 'ổ cắm' được chuyển đến tham số tên. (Đóng góp bởi Yury Selivanov trong bpo-37027. )

  • def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    205 đã chuyển sang API ổn định

  • Phụ thuộc DLL cho các mô-đun mở rộng và DLL được tải bằng 

    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    65 trên Windows hiện đã được giải quyết an toàn hơn. Chỉ các đường dẫn hệ thống, thư mục chứa tệp DLL hoặc PYD và các thư mục được thêm bằng 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    23 mới được tìm kiếm phụ thuộc thời gian tải. Specifically, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    208 and the current working directory are no longer used, and modifications to these will no longer have any effect on normal DLL resolution. Nếu ứng dụng của bạn dựa vào các cơ chế này, bạn nên kiểm tra 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    23 và nếu nó tồn tại, hãy sử dụng nó để thêm thư mục DLL của bạn trong khi tải thư viện của bạn. Lưu ý rằng người dùng Windows 7 sẽ cần đảm bảo rằng Windows Update KB2533623 đã được cài đặt (điều này cũng được trình cài đặt xác minh). (Đóng góp bởi Steve Dower trong bpo-36085. )

  • Các tệp tiêu đề và chức năng liên quan đến pgen đã bị xóa sau khi thay thế nó bằng triển khai Python thuần túy. (Đóng góp bởi Pablo Galindo trong bpo-36623. )

  • discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    57 has a new parameter in the second position of the constructor (posonlyargcount) to support positional-only arguments defined in PEP 570. Đối số đầu tiên (argcount) hiện đại diện cho tổng số đối số vị trí (bao gồm cả đối số chỉ vị trí). Phương pháp 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    58 mới của 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    57 có thể được sử dụng để làm cho mã trở thành bằng chứng trong tương lai

  • The parameter 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    213 for 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    214 no longer uses the MD5 digest by default

Changes in the C API¶

  • Cấu trúc 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    215 có trường cf_feature_version mới. Nó nên được khởi tạo thành 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    216. Trường bị bỏ qua theo mặc định và được sử dụng khi và chỉ khi cờ 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    217 được đặt trong cf_flags. (Contributed by Guido van Rossum in bpo-35766. )

  • Hàm 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    218 đã bị xóa khỏi API C. Nó không nên được gọi một cách rõ ràng. sử dụng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    219 thay thế. (Đóng góp bởi Victor Stinner trong bpo-36728. )

  • Trên Unix, các tiện ích mở rộng của C không còn được liên kết với libpython ngoại trừ trên Android và Cygwin. Khi Python được nhúng, không được tải 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    220 cùng với 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    221 mà thay vào đó là 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    222. Trước đây, khi sử dụng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    221, không thể tải các tiện ích mở rộng C không được liên kết với 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    220, giống như các tiện ích mở rộng C của thư viện chuẩn được xây dựng bởi phần 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    225 của 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    58. (Contributed by Victor Stinner in bpo-21536. )

  • Sử dụng các biến thể của định dạng 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    227 trong phân tích cú pháp hoặc xây dựng giá trị (e. g. 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    63, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    229, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    230, v.v. ) không có 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    231 được xác định tăng 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    92 ngay bây giờ. It will be removed in 3. 10 hoặc 4. 0. Đọc Phân tích đối số và xây dựng giá trị để biết chi tiết. (Đóng góp bởi Inada Naoki trong bpo-36381. )

  • Các thể hiện của các loại được phân bổ trong đống (chẳng hạn như các loại được tạo bằng 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    233) giữ một tham chiếu đến đối tượng loại của chúng. Việc tăng số lượng tham chiếu của các đối tượng loại này đã được chuyển từ 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    80 sang các hàm cấp thấp hơn, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    78 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    47. Điều này làm cho các loại được tạo thông qua 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    233 hoạt động giống như các lớp khác trong mã được quản lý

    Các loại được phân bổ tĩnh không bị ảnh hưởng.

    For the vast majority of cases, there should be no side effect. Tuy nhiên, các loại tăng số lượng tham chiếu theo cách thủ công sau khi phân bổ một phiên bản (có lẽ để khắc phục lỗi) giờ đây có thể trở thành bất tử. Để tránh điều này, các lớp này cần gọi Py_DECREF trên đối tượng loại trong khi phân bổ cá thể

    Để chuyển chính xác các loại này thành 3. 8, vui lòng áp dụng các thay đổi sau

    • Xóa 

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      238 trên đối tượng loại sau khi phân bổ một thể hiện - nếu có. Điều này có thể xảy ra sau khi gọi 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      239, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      240, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      241, 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      242 hoặc bất kỳ trình phân bổ tùy chỉnh nào khác sử dụng 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      78 hoặc 
      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      47

      Ví dụ

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      1

    • Đảm bảo rằng tất cả các hàm 

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      245 tùy chỉnh của các loại được phân bổ theo đống sẽ giảm số lượng tham chiếu của loại

      Ví dụ

      def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
      2

    (Đóng góp bởi Eddie Elizondo trong bpo-35810. )

  • The 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    246 macro has been implemented for MSVC. Macro bây giờ phải được đặt trước tên biểu tượng

    Ví dụ

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    3

    (Đóng góp bởi Zackery Spytz trong bpo-33407. )

  • The interpreter does not pretend to support binary compatibility of extension types across feature releases, anymore. Một 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    247 được xuất bởi mô-đun mở rộng của bên thứ ba được cho là có tất cả các vị trí dự kiến ​​trong phiên bản Python hiện tại, bao gồm cả 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    248 (
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    249 không được kiểm tra nữa trước khi đọc 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    248)

    (Contributed by Antoine Pitrou in bpo-32388. )

  • Các hàm 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    251 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    252 hiện chấp nhận thêm hai đối số 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    29 end_lineno và end_col_offset

  • Tệp 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    254 để cho phép các công cụ MinGW liên kết trực tiếp với 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    255 không còn được bao gồm trong bản phân phối Windows thông thường. If you require this file, it may be generated with the 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    256 and 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    257 tools, which are part of the MinGW binutils package

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    4

    Vị trí của một 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    258 được cài đặt sẽ phụ thuộc vào các tùy chọn cài đặt cũng như phiên bản và ngôn ngữ của Windows. Xem Sử dụng Python trên Windows để biết thêm thông tin. Thư viện kết quả phải được đặt trong cùng thư mục với 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    259, thường là thư mục 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    260 trong bản cài đặt Python của bạn.

    (Đóng góp bởi Steve Dower trong bpo-37351. )

CPython bytecode changes¶

  • Vòng lặp thông dịch đã được đơn giản hóa bằng cách di chuyển logic hủy kiểm soát chồng khối vào trình biên dịch. Trình biên dịch hiện phát ra các hướng dẫn rõ ràng để điều chỉnh ngăn xếp giá trị và gọi mã dọn dẹp cho 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    261, 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    26 và 
    discount = 0.0
if (mo := re.search(r'(\d+)% discount', advertisement)):
    discount = float(mo.group(1)) / 100.0
    47

    Đã xóa opcodes 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    264, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    265, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    266 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    267. Đã thêm opcodes mới 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    268, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    269, 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    270 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    271. Đã thay đổi hành vi của 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    272 và 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    273

    (Đóng góp bởi Mark Shannon, Antoine Pitrou và Serhiy Storchaka trong bpo-17611. )

  • Added new opcode 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    274 for handling exceptions raised when awaiting a next item in an 
    # Loop over fixed length blocks
while (block := f.read(256)) != '':
    process(block)
    07 loop. (Đóng góp bởi Serhiy Storchaka trong bpo-33041. )

  • Hiện tại, 

    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    276 mong muốn giá trị là phần tử đầu tiên trong ngăn xếp và khóa là phần tử thứ hai. Thay đổi này được thực hiện để khóa luôn được đánh giá trước giá trị trong cách hiểu từ điển, theo đề xuất của PEP 572. (Đóng góp bởi Jörn Heissler trong bpo-35224. )

Trình diễn và Công cụ¶

Đã thêm một tập lệnh điểm chuẩn để định thời gian theo nhiều cách khác nhau để truy cập các biến. 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
277. (Contributed by Raymond Hettinger in bpo-35884. )

Dưới đây là tóm tắt về các cải tiến hiệu suất kể từ Python 3. 3

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
5

Điểm chuẩn được đo trên bộ xử lý Intel® Core™ i7-4960HQ chạy bản dựng macOS 64-bit có tại python. tổ chức. The benchmark script displays timings in nanoseconds

Notable changes in Python 3. 8. 1¶

Do những lo ngại đáng kể về bảo mật, thông sốuse_address của 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
278 không còn được hỗ trợ. Điều này là do hành vi của tùy chọn ổ cắm 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
279 trong UDP. Để biết thêm chi tiết, hãy xem tài liệu về 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
280. (Đóng góp bởi Kyle Stanley, Antoine Pitrou, và Yury Selivanov trong bpo-37228. )

Những thay đổi đáng chú ý trong Python 3. 8. số 8¶

Các phiên bản Python trước đó cho phép sử dụng cả 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
281 và 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
282 làm dấu tách tham số truy vấn trong 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
283 và 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
284. Do những lo ngại về bảo mật và để phù hợp với các khuyến nghị mới hơn của W3C, điều này đã được thay đổi để chỉ cho phép một khóa phân tách duy nhất, với _____1282 làm mặc định. Thay đổi này cũng ảnh hưởng đến 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
286 và 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
287 khi họ sử dụng các chức năng bị ảnh hưởng trong nội bộ. For more details, please see their respective documentation. (Đóng góp bởi Adam Goldschmidt, Senthil Kumaran và Ken Jin trong bpo-42967. )

Notable changes in Python 3. 8. 12¶

Bắt đầu với Python 3. 8. 12 mô-đun 

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
288 không còn chấp nhận bất kỳ số 0 đứng đầu nào trong chuỗi địa chỉ IPv4. Các số 0 ở đầu không rõ ràng và được một số thư viện hiểu là ký hiệu bát phân. For example the legacy function 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
289 treats leading zeros as octal notation. triển khai glibc của 
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
290 hiện đại không chấp nhận bất kỳ số 0 đứng đầu nào

Việc sử dụng toán tử '%' trong Python là gì?

Ký hiệu % trong Python được gọi là Toán tử Modulo. Nó trả về phần còn lại của phép chia toán hạng bên trái cho toán hạng bên phải .

What are the 7 operators in Python?

Python Operators .
Arithmetic operators
Toán tử gán
Toán tử so sánh
Toán tử logic
Toán tử nhận dạng
nhà khai thác thành viên
Bitwise operators

%= có phải là toán tử trong Python không?

Here, = is an assignment operator that assigns 5 to x . Đây là danh sách các toán tử gán khác nhau có sẵn trong Python. . 2. Toán tử gán trong Python

3 toán tử logic trong Python là gì?

Python offers three logical or boolean operators, "and", "or" and "not" operators . These work on one or more operands, and depending on their values, evaluate to True or False.

programming python

Bài Viết Liên Quan

WordPress mở trong tab mới không hoạt động
WordPress mở trong tab mới không hoạt động

Tôi nên sử dụng văn bản bên trong hoặc bên trong html?
Tôi nên sử dụng văn bản bên trong hoặc bên trong html?

Atexit Python
Atexit Python

Trích xuất văn bản từ hình ảnh bằng opencv python github
Trích xuất văn bản từ hình ảnh bằng opencv python github

Phương pháp máy chủ email tốt nhất cho Gmail là gì?
Phương pháp máy chủ email tốt nhất cho Gmail là gì?

Let có cần thiết trong JavaScript không?
Let có cần thiết trong JavaScript không?

Làm cách nào để xác thực số thập phân trong JavaScript?
Làm cách nào để xác thực số thập phân trong JavaScript?

Php get_resource
Php get_resource

Khi nào tôi nên nộp đơn cho kỳ nhập học tháng 9 năm 2023?
Khi nào tôi nên nộp đơn cho kỳ nhập học tháng 9 năm 2023?

West Bengal Holiday List 2023
West Bengal Holiday List 2023

MỚI CẬP NHẬP

Máy in brother l27010 báo lỗi replace toner cartridge năm 2024
2 phúts trước . bởi UncontrollableVictory
Bài tập tính tóan thương mại quốc tế năm 2024
18 phúts trước . bởi HauntedDamsel
Thụy hồng-thái thụy thái bình xưa là xã huyện nào năm 2024
43 phúts trước . bởi ConfidentSperm
Các dạng bài về tập hợp lớp 10 năm 2024
1 giờs trước . bởi MusicalIndicator
Sữa lỗi không xem fb lite trong nõ năm 2024
1 giờs trước . bởi IrrevocableAtheism
Dùng điện 12v và 220v cái nào tiết kiệm hơn năm 2024
1 giờs trước . bởi CheeryProspectus
Bài tập về khối đa diện có lời giải năm 2024
2 giờs trước . bởi FineEmbodiment
Bài tập toán lớp 4 có lời giải năm 2024
2 giờs trước . bởi UndefeatedSophistication
Bài văn mẫu lớp 2 tả về cây năm 2024
3 giờs trước . bởi AdvantageousApartheid
Bài tập tự luận chương 3 vật lý 7 năm 2024
3 giờs trước . bởi SedateHello

Xem Nhiều

Thế nào là tầng cao trung bình năm 2024
1 ngàys trước . bởi QualifyingDefinition
Top ngân hàng cho vay lãi suất thấp 2023 năm 2024
4 ngàys trước . bởi OngoingEmbroidery
Sữa rửa mặt nào dùng cho bà bầu năm 2024
2 ngàys trước . bởi GenerativeCreator
Quà tặng cho doanh nghiệp có phải xuất hóa đơn năm 2024
1 ngàys trước . bởi UnrelatedDriver
Lỗi không mở được adobe after effect potable năm 2024
10 giờs trước . bởi BrilliantCracker
Bài 26 trang 12 sgk toán 8 tập 1 năm 2024
16 giờs trước . bởi ConspiratorialIceberg
Giải bài tập tiếng anh 10 thí điểm unit 9 năm 2024
5 ngàys trước . bởi TribalHousing
Bài tập lý thuyết hóa ancol phenol 11 năm 2024
5 ngàys trước . bởi InternalBrunch
Lỗi sạc pin trên android 7.0 nougat sạc pin 97 năm 2024
2 ngàys trước . bởi StreamlinedClutches
Tỷ giá usd trung bình tháng 5 2023 năm 2024
1 ngàys trước . bởi DismalCollege

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Bản quyền © 2024 Inc.