Hướng dẫn is print () supported in python 3? - print () có được hỗ trợ trong python 3 không?

Tác giả

Guido Van Rossum

Bài viết này giải thích các tính năng mới trong Python 3.0, so với 2.6. Python 3.0, còn được gọi là Hồi Python 3000, hay PY3K, là bản phát hành Python không tương thích đầu tiên. Python 3.0 được phát hành vào ngày 3 tháng 12 năm 2008. Có nhiều thay đổi hơn trong một bản phát hành điển hình và nhiều hơn nữa là quan trọng đối với tất cả người dùng Python. Tuy nhiên, sau khi tiêu hóa các thay đổi, bạn sẽ thấy rằng Python thực sự đã thay đổi tất cả-bởi và lớn, chúng tôi chủ yếu sửa chữa những phiền toái và mụn cóc nổi tiếng, và loại bỏ rất nhiều Cruft cũ.

Bài viết này không cố gắng cung cấp một đặc điểm kỹ thuật đầy đủ về tất cả các tính năng mới, nhưng thay vào đó cố gắng đưa ra một cái nhìn tổng quan thuận tiện. Để biết chi tiết đầy đủ, bạn nên tham khảo tài liệu cho Python 3.0 và/hoặc nhiều PEP được tham chiếu trong văn bản. Nếu bạn muốn hiểu lý do thực hiện và thiết kế hoàn chỉnh cho một tính năng cụ thể, PEPS thường có nhiều chi tiết hơn tài liệu thông thường; Nhưng lưu ý rằng PEP thường không được cập nhật một khi một tính năng đã được thực hiện đầy đủ.

Do các ràng buộc về thời gian, tài liệu này không đầy đủ như nó nên có. Như mọi khi cho một bản phát hành mới, tệp Misc/NEWS trong phân phối nguồn chứa rất nhiều thông tin chi tiết về mọi điều nhỏ nhặt đã được thay đổi.

Vấp ngã thông thường

Phần này liệt kê một vài thay đổi có khả năng nhất sẽ vượt qua bạn nếu bạn đã từng sử dụng Python 2.5.

In là một chức năng

Tuyên bố print đã được thay thế bằng hàm print[], với các đối số từ khóa để thay thế hầu hết các cú pháp đặc biệt của câu lệnh print cũ [PEP 3105]. Ví dụ:PEP 3105]. Examples:

Old: print "The answer is", 2*2
New: print["The answer is", 2*2]

Old: print x,           # Trailing comma suppresses newline
New: print[x, end=" "]  # Appends a space instead of a newline

Old: print              # Prints a newline
New: print[]            # You must call the function!

Old: print >>sys.stderr, "fatal error"
New: print["fatal error", file=sys.stderr]

Old: print [x, y]       # prints repr[[x, y]]
New: print[[x, y]]      # Not the same as print[x, y]!

Bạn cũng có thể tùy chỉnh phân tách giữa các mục, ví dụ:

print["There are  possibilities!", sep=""]

sản xuất:

There are  possibilities!

Note:

Chức năng print[] không hỗ trợ tính năng của Softspace, của câu lệnh print cũ. Ví dụ, trong Python 2.x,

print["There are  possibilities!", sep=""]

2 sẽ viết

print["There are  possibilities!", sep=""]

3; Nhưng trong Python 3.0,

print["There are  possibilities!", sep=""]

4 viết

print["There are  possibilities!", sep=""]

Ban đầu, bạn sẽ thấy mình gõ
```
print["There are  possibilities!", sep=""]
```
6 cũ rất nhiều ở chế độ tương tác. Thời gian để kiềm chế ngón tay của bạn để gõ
```
print["There are  possibilities!", sep=""]
```
7 thay thế!
Khi sử dụng công cụ chuyển đổi nguồn sang nguồn
```
print["There are  possibilities!", sep=""]
```
8, tất cả các câu lệnh print sẽ tự động chuyển đổi thành các cuộc gọi chức năng print[], vì vậy đây chủ yếu là không có vấn đề cho các dự án lớn hơn.

Lượt xem và lặp lại thay vì danh sách

Một số API nổi tiếng không còn danh sách trả về:

```
There are  possibilities!
```
1 Phương pháp
```
There are  possibilities!
```
2,
```
There are  possibilities!
```
3 và
```
There are  possibilities!
```
4 Trả về lượt xem trực tiếp thay vì danh sách. Ví dụ, điều này không còn hoạt động:
```
There are  possibilities!
```
5. Sử dụng
```
There are  possibilities!
```
6 thay thế [điều này hoạt động trong Python 2.5 cũng vậy và cũng hiệu quả].

Ngoài ra, các phương pháp

There are  possibilities!

There are  possibilities!

8 và

There are  possibilities!

9 không còn được hỗ trợ.

```
class C:
    __metaclass__ = M
    ...
```
0 và
```
class C:
    __metaclass__ = M
    ...
```
1 trả về trình lặp lại. Nếu bạn thực sự cần một danh sách và các chuỗi đầu vào đều có độ dài bằng nhau, một bản sửa lỗi nhanh là kết thúc
```
class C:
    __metaclass__ = M
    ...
```
0 trong
```
class C:
    __metaclass__ = M
    ...
```
3, ví dụ:
```
class C:
    __metaclass__ = M
    ...
```
4, nhưng một bản sửa lỗi tốt hơn thường là sử dụng khả năng hiểu danh sách [đặc biệt là khi mã gốc sử dụng
```
class C:
    __metaclass__ = M
    ...
```
5] hoặc viết lại mã để nó không cần một danh sách. Đặc biệt khó khăn là
```
class C:
    __metaclass__ = M
    ...
```
0 được gọi cho các tác dụng phụ của chức năng; Việc chuyển đổi chính xác là sử dụng vòng lặp
```
class C:
    __metaclass__ = M
    ...
```
7 thông thường [vì việc tạo danh sách sẽ chỉ là lãng phí].
Nếu các chuỗi đầu vào không có độ dài bằng nhau,
```
class C:
    __metaclass__ = M
    ...
```
0 sẽ dừng khi chấm dứt thời gian ngắn nhất của các chuỗi. Để có khả năng tương thích đầy đủ với
```
class C:
    __metaclass__ = M
    ...
```
0 từ Python 2.x, cũng bao gồm các chuỗi trong
```
class C[metaclass=M]:
    ...
```
0, ví dụ:
```
class C[metaclass=M]:
    ...
```
1 trở thành
```
class C[metaclass=M]:
    ...
```
2.
```
class C[metaclass=M]:
    ...
```
3 bây giờ hoạt động như
```
class C[metaclass=M]:
    ...
```
4 được sử dụng để cư xử, ngoại trừ nó hoạt động với các giá trị có kích thước tùy ý. Cái sau không còn tồn tại.
```
class C[metaclass=M]:
    ...
```
5 Bây giờ trả về một iterator.

Đặt hàng so sánh Jo

Python 3.0 đã đơn giản hóa các quy tắc để đặt hàng so sánh:

Các toán tử so sánh đặt hàng [
```
class C[metaclass=M]:
    ...
```
6,
```
class C[metaclass=M]:
    ...
```
7,
```
class C[metaclass=M]:
    ...
```
8,
```
class C[metaclass=M]:
    ...
```
9] nêu ra một ngoại lệ kiểu loại khi các toán hạng don don có một thứ tự tự nhiên có ý nghĩa. Do đó, các biểu thức như
```
raise SecondaryException[] from primary_exception
```
0,
```
raise SecondaryException[] from primary_exception
```
1 hoặc
```
raise SecondaryException[] from primary_exception
```
2 không còn hợp lệ và ví dụ:
```
raise SecondaryException[] from primary_exception
```
3 tăng
```
raise SecondaryException[] from primary_exception
```
4 thay vì trả lại
```
raise SecondaryException[] from primary_exception
```
5. Một hệ quả là việc sắp xếp một danh sách không đồng nhất không còn có ý nghĩa - tất cả các yếu tố phải được so sánh với nhau. Lưu ý rằng điều này không áp dụng cho các toán tử
```
raise SecondaryException[] from primary_exception
```
6 và
```
raise SecondaryException[] from primary_exception
```
7: các đối tượng của các loại không thể so sánh khác nhau luôn so sánh không đồng đều với nhau.
```
raise SecondaryException[] from primary_exception
```
8 và
```
raise SecondaryException[] from primary_exception
```
9 không còn chấp nhận đối số CMP cung cấp hàm so sánh. Sử dụng đối số chính thay thế. N.B. Các đối số chính và ngược bây giờ chỉ là từ khóa.
Hàm Misc/NEWS0 nên được coi là biến mất và phương pháp đặc biệt Misc/NEWS1 không còn được hỗ trợ. Sử dụng Misc/NEWS2 để sắp xếp, Misc/NEWS3 với Misc/NEWS4 và các so sánh phong phú khác khi cần thiết. [Nếu bạn thực sự cần chức năng Misc/NEWS0, bạn có thể sử dụng biểu thức Misc/NEWS6 tương đương với Misc/NEWS7.]

Số nguyên

PEP 237: Về cơ bản, Misc/NEWS8 được đổi tên thành Misc/NEWS9. Đó là, chỉ có một loại tích phân tích hợp, có tên là Misc/NEWS9; Nhưng nó hoạt động chủ yếu giống như loại Misc/NEWS8 cũ.: Essentially, Misc/NEWS8 renamed to Misc/NEWS9. That is, there is only one built-in integral type, named Misc/NEWS9; but it behaves mostly like the old Misc/NEWS8 type.
PEP 238: Một biểu thức như print2 trả về một chiếc phao. Sử dụng print3 để có được hành vi cắt ngắn. [Cú pháp thứ hai đã tồn tại trong nhiều năm, ít nhất là kể từ Python 2.2.]: An expression like print2 returns a float. Use print3 to get the truncating behavior. [The latter syntax has existed for years, at least since Python 2.2.]
Hằng số print4 đã được loại bỏ, vì không còn giới hạn giá trị của số nguyên. Tuy nhiên, print5 có thể được sử dụng như một số nguyên lớn hơn bất kỳ danh sách thực tế hoặc chỉ mục chuỗi thực tế. Nó phù hợp với việc triển khai kích thước số nguyên tự nhiên của bạn và thường giống như print4 trong các bản phát hành trước trên cùng một nền tảng [giả sử cùng một tùy chọn xây dựng].
print7 của một số nguyên dài không bao gồm dấu ngoặc ____ ____78 nữa, do đó, mã mà các dải vô điều kiện đó sẽ cắt bỏ chữ số cuối cùng thay thế. [Sử dụng print9 thay thế.]
Biết chữ cái không còn ở dạng print[]0; sử dụng print[]1 thay thế.

Văn bản Vs. Dữ liệu thay vì Unicode Vs. 8 bit¶

Tất cả mọi thứ bạn nghĩ bạn biết về dữ liệu nhị phân và Unicode đã thay đổi.

Python 3.0 sử dụng các khái niệm về dữ liệu văn bản và [nhị phân] thay vì chuỗi unicode và chuỗi 8 bit. Tất cả văn bản là Unicode; Tuy nhiên, unicode được mã hóa được biểu diễn dưới dạng dữ liệu nhị phân. Loại được sử dụng để giữ văn bản là print[]2, loại được sử dụng để giữ dữ liệu là print[]3. Sự khác biệt lớn nhất với tình huống 2.x là bất kỳ nỗ lực trộn văn bản và dữ liệu trong Python 3.0 đều tăng
```
raise SecondaryException[] from primary_exception
```
4, trong khi nếu bạn trộn các chuỗi unicode và 8 bit trong Python 2.x, nó sẽ hoạt động nếu 8 bit Chuỗi chỉ chứa các byte 7 bit [ASCII], nhưng bạn sẽ nhận được print[]5 nếu nó chứa các giá trị không ASCII. Hành vi cụ thể giá trị này đã gây ra nhiều khuôn mặt buồn trong những năm qua.
Do hậu quả của sự thay đổi này trong triết học, hầu hết tất cả các mã sử dụng Unicode, mã hóa hoặc dữ liệu nhị phân rất có thể phải thay đổi. Sự thay đổi là tốt hơn, vì trong thế giới 2.x, có rất nhiều lỗi phải làm với việc trộn văn bản được mã hóa và không được mã hóa. Để được chuẩn bị trong Python 2.x, hãy bắt đầu sử dụng print[]6 cho tất cả các văn bản không được mã hóa và print[]2 chỉ cho dữ liệu nhị phân hoặc được mã hóa. Sau đó, công cụ
```
print["There are  possibilities!", sep=""]
```
8 sẽ làm hầu hết công việc cho bạn.
Bạn không còn có thể sử dụng print[]9 nghĩa đen cho văn bản Unicode. Tuy nhiên, bạn phải sử dụng các chữ print0 cho dữ liệu nhị phân.
Vì các loại print[]2 và print[]3 không thể được trộn lẫn, bạn phải luôn luôn chuyển đổi rõ ràng giữa chúng. Sử dụng print3 để đi từ print[]2 đến print[]3 và print6 để đi từ print[]3 đến print[]2. Bạn cũng có thể sử dụng print9 và
```
print["There are  possibilities!", sep=""]
```
00, tương ứng.
Giống như print[]2, loại print[]3 là bất biến. Có một loại đột biến riêng biệt để giữ dữ liệu nhị phân được đệm,
```
print["There are  possibilities!", sep=""]
```
03. Gần như tất cả các API chấp nhận print[]3 cũng chấp nhận
```
print["There are  possibilities!", sep=""]
```
03. API có thể thay đổi dựa trên
```
print["There are  possibilities!", sep=""]
```
06.
Tất cả các dấu gạch chéo ngược trong các chuỗi chữ thô được giải thích theo nghĩa đen. Điều này có nghĩa là
```
print["There are  possibilities!", sep=""]
```
07 và
```
print["There are  possibilities!", sep=""]
```
08 trốn thoát trong các chuỗi thô không được xử lý đặc biệt. Ví dụ,
```
print["There are  possibilities!", sep=""]
```
09 là một chuỗi 6 ký tự trong Python 3.0, trong khi trong 2.6,
```
print["There are  possibilities!", sep=""]
```
10 là nhân vật duy nhất của Euro Euro. .
Loại trừu tượng
```
print["There are  possibilities!", sep=""]
```
12 tích hợp đã được loại bỏ. Sử dụng print[]2 thay thế. Các loại print[]2 và print[]3 don don có chức năng đủ chung để đảm bảo một lớp cơ sở chung. Công cụ
```
print["There are  possibilities!", sep=""]
```
8 [xem bên dưới] thay thế mọi lần xuất hiện của
```
print["There are  possibilities!", sep=""]
```
12 bằng print[]2.
Các tệp được mở dưới dạng tệp văn bản [vẫn là chế độ mặc định cho
```
print["There are  possibilities!", sep=""]
```
19] luôn sử dụng mã hóa để ánh xạ giữa các chuỗi [trong bộ nhớ] và byte [trên đĩa]. Các tệp nhị phân [được mở bằng
```
print["There are  possibilities!", sep=""]
```
20 trong đối số chế độ] luôn sử dụng byte trong bộ nhớ. Điều này có nghĩa là nếu một tệp được mở bằng chế độ hoặc mã hóa không chính xác, I/O có thể sẽ thất bại lớn, thay vì âm thầm tạo dữ liệu không chính xác. Điều đó cũng có nghĩa là ngay cả người dùng Unix cũng sẽ phải chỉ định chế độ chính xác [văn bản hoặc nhị phân] khi mở tệp. Có một mã hóa mặc định phụ thuộc vào nền tảng, trên các nền tảng UNIXY có thể được đặt với biến môi trường
```
print["There are  possibilities!", sep=""]
```
21 [và đôi khi cũng với một số biến môi trường liên quan đến địa phương cụ thể khác]. Trong nhiều trường hợp, nhưng không phải tất cả, mặc định hệ thống là UTF-8; Bạn không bao giờ nên tin tưởng vào mặc định này. Bất kỳ ứng dụng đọc hoặc viết nhiều hơn văn bản ASCII thuần túy có lẽ nên có cách ghi đè mã hóa. Không còn bất kỳ nhu cầu nào trong việc sử dụng các luồng nhận biết mã hóa trong mô-đun
```
print["There are  possibilities!", sep=""]
```
22.
Các giá trị ban đầu của
```
print["There are  possibilities!", sep=""]
```
23,
```
print["There are  possibilities!", sep=""]
```
24 và
```
print["There are  possibilities!", sep=""]
```
25 hiện là các tệp văn bản chỉ dành cho Unicode [tức là, chúng là các trường hợp của
```
print["There are  possibilities!", sep=""]
```
26]. Để đọc và ghi dữ liệu byte với các luồng này, bạn cần sử dụng thuộc tính
```
print["There are  possibilities!", sep=""]
```
27 của chúng.
Tên tệp được truyền và trả về từ API dưới dạng chuỗi [Unicode]. Điều này có thể trình bày các vấn đề cụ thể về nền tảng bởi vì trên một số tên tệp là chuỗi byte tùy ý. . Có một cách để yêu cầu giá trị trả về print[]3. Do đó,
```
print["There are  possibilities!", sep=""]
```
32 trả về danh sách các trường hợp print[]3 nếu đối số là một ví dụ print[]3 và
```
print["There are  possibilities!", sep=""]
```
35 trả về thư mục làm việc hiện tại dưới dạng ví dụ print[]3. Lưu ý rằng khi
```
print["There are  possibilities!", sep=""]
```
32 trả về một danh sách các chuỗi, các tên tệp không thể được giải mã đúng được bỏ qua thay vì tăng
```
print["There are  possibilities!", sep=""]
```
38.
Một số API hệ thống như
```
print["There are  possibilities!", sep=""]
```
39 và
```
print["There are  possibilities!", sep=""]
```
40 cũng có thể đưa ra các vấn đề khi các byte được hệ thống cung cấp không thể diễn giải bằng cách sử dụng mã hóa mặc định. Đặt biến
```
print["There are  possibilities!", sep=""]
```
21 và chạy lại chương trình có lẽ là cách tiếp cận tốt nhất.
PEP 3138: print7 của một chuỗi không còn thoát khỏi các ký tự không phải là ASCII. Tuy nhiên, nó vẫn thoát khỏi các ký tự điều khiển và điểm mã với trạng thái không thể in trong tiêu chuẩn Unicode.: The print7 of a string no longer escapes non-ASCII characters. It still escapes control characters and code points with non-printable status in the Unicode standard, however.
PEP 3120: Mã hóa nguồn mặc định hiện là UTF-8.: The default source encoding is now UTF-8.
PEP 3131: Các chữ cái không phải ASCII hiện được phép trong các định danh. [Tuy nhiên, thư viện tiêu chuẩn vẫn là ASCII-chỉ ngoại trừ tên người đóng góp trong nhận xét.]: Non-ASCII letters are now allowed in identifiers. [However, the standard library remains ASCII-only with the exception of contributor names in comments.]

Các mô -đun

print["There are  possibilities!", sep=""]

43 và

print["There are  possibilities!", sep=""]

44 đã biến mất. Thay vào đó, hãy nhập mô -đun

print["There are  possibilities!", sep=""]

45 và sử dụng

print["There are  possibilities!", sep=""]

46 hoặc

print["There are  possibilities!", sep=""]

47 cho văn bản và dữ liệu tương ứng.

Xem thêm Unicode Howto, được cập nhật cho Python 3.0.Unicode HOWTO, which was updated for Python 3.0.

Tổng quan về các thay đổi cú pháp

Phần này cung cấp một cái nhìn tổng quan ngắn gọn về mọi thay đổi cú pháp trong Python 3.0.

Cú pháp mới

PEP 3107: Đối số chức năng và chú thích giá trị trả về. Điều này cung cấp một cách tiêu chuẩn hóa để chú thích các tham số chức năng và giá trị trả về. Không có ngữ nghĩa nào được gắn vào các chú thích như vậy ngoại trừ việc chúng có thể bị xâm nhập vào thời gian chạy bằng cách sử dụng thuộc tính
```
print["There are  possibilities!", sep=""]
```
48. Mục đích là để khuyến khích thử nghiệm thông qua các metaclass, người trang trí hoặc khung.: Function argument and return value annotations. This provides a standardized way of annotating a function’s parameters and return value. There are no semantics attached to such annotations except that they can be introspected at runtime using the
```
print["There are  possibilities!", sep=""]
```
48 attribute. The intent is to encourage experimentation through metaclasses, decorators or frameworks.
PEP 3102: Đối số chỉ từ khóa. Các tham số được đặt tên xảy ra sau khi
```
print["There are  possibilities!", sep=""]
```
49 trong danh sách tham số phải được chỉ định bằng cú pháp từ khóa trong cuộc gọi. Bạn cũng có thể sử dụng một
print["There are possibilities!", sep=""]
50 trong danh sách tham số để cho biết rằng bạn không chấp nhận danh sách đối số có độ dài thay đổi, nhưng bạn có các đối số chỉ dành cho từ khóa.: Keyword-only arguments. Named parameters occurring after
```
print["There are  possibilities!", sep=""]
```
49 in the parameter list must be specified using keyword syntax in the call. You can also use a bare
```
print["There are  possibilities!", sep=""]
```
50 in the parameter list to indicate that you don’t accept a variable-length argument list, but you do have keyword-only arguments.
Đối số từ khóa được cho phép sau danh sách các lớp cơ sở trong một định nghĩa lớp. Điều này được sử dụng bởi quy ước mới để chỉ định một metaclass [xem phần tiếp theo], nhưng cũng có thể được sử dụng cho các mục đích khác, miễn là Metaclass hỗ trợ nó.
PEP 3104: Tuyên bố
```
print["There are  possibilities!", sep=""]
```
51. Sử dụng
print["There are possibilities!", sep=""]
52 Bây giờ bạn có thể gán trực tiếp cho một biến trong phạm vi bên ngoài [nhưng không toàn cầu].
print["There are possibilities!", sep=""]
51 là một từ dành riêng mới.:
```
print["There are  possibilities!", sep=""]
```
51 statement. Using
```
print["There are  possibilities!", sep=""]
```
52 you can now assign directly to a variable in an outer [but non-global] scope.
```
print["There are  possibilities!", sep=""]
```
51 is a new reserved word.
PEP 3132: Mở rộng không thể giải nén. Bây giờ bạn có thể viết những thứ như
```
print["There are  possibilities!", sep=""]
```
54. Và thậm chí
print["There are possibilities!", sep=""]
55. Đối tượng
print["There are possibilities!", sep=""]
56 luôn là một danh sách [có thể trống]; Phía bên tay phải có thể là bất kỳ điều đó. Thí dụ:: Extended Iterable Unpacking. You can now write things like
```
print["There are  possibilities!", sep=""]
```
54. And even
```
print["There are  possibilities!", sep=""]
```
55. The
```
print["There are  possibilities!", sep=""]
```
56 object is always a [possibly empty] list; the right-hand side may be any iterable. Example:
Điều này đặt A đến
```
print["There are  possibilities!", sep=""]
```
57, B đến
```
print["There are  possibilities!", sep=""]
```
58 và phần còn lại thành
```
print["There are  possibilities!", sep=""]
```
59.
Hiểu về từ điển:
```
print["There are  possibilities!", sep=""]
```
60 có nghĩa là giống như
```
print["There are  possibilities!", sep=""]
```
61 nhưng linh hoạt hơn. [Đây là PEP 274 được minh oan. :-]PEP 274 vindicated. :-]

Đặt chữ, ví dụ:

print["There are  possibilities!", sep=""]

62. Lưu ý rằng

print["There are  possibilities!", sep=""]

63 là một từ điển trống; Sử dụng

print["There are  possibilities!", sep=""]

64 cho một bộ trống. Đặt toàn bộ cũng được hỗ trợ; ví dụ:

print["There are  possibilities!", sep=""]

65 có nghĩa là giống như

print["There are  possibilities!", sep=""]

66 nhưng linh hoạt hơn.

Bình luận mới, ví dụ: print[]1 [đã có trong 2.6]. Các chữ Octal cũ [print[]0] đã biến mất.
Văn học nhị phân mới, ví dụ:
```
print["There are  possibilities!", sep=""]
```
69 [đã có trong 2.6] và có chức năng tích hợp tương ứng mới,
```
print["There are  possibilities!", sep=""]
```
70.

BYTE LIÊN QUAN ĐƯỢC GIỚI THIỆU VỚI MỘT

print["There are  possibilities!", sep=""]

20 hoặc

print["There are  possibilities!", sep=""]

72, và có một chức năng tích hợp tương ứng mới,

print["There are  possibilities!", sep=""]

73.

Đã thay đổi cú pháp

PEP 3109 và PEP 3134: Cú pháp tuyên bố

print["There are  possibilities!", sep=""]

74 mới:
print["There are possibilities!", sep=""]
75. Xem bên dưới. and PEP 3134: new

print["There are  possibilities!", sep=""]

74 statement syntax:

print["There are  possibilities!", sep=""]

75. See below.

print["There are  possibilities!", sep=""]

76 và

print["There are  possibilities!", sep=""]

77 hiện là những từ dành riêng. [Vì 2.6, thực sự.]

print["There are  possibilities!", sep=""]

78,

raise SecondaryException[] from primary_exception

5 và

print["There are  possibilities!", sep=""]

80 là những từ dành riêng. [2.6 đã thực thi một phần các hạn chế đối với

print["There are  possibilities!", sep=""]

80 rồi.]

Thay đổi từ

print["There are  possibilities!", sep=""]

82 exc, var thành

print["There are  possibilities!", sep=""]

82 exc

print["There are  possibilities!", sep=""]

76 var. Xem PEP 3110.PEP 3110.

PEP 3115: Cú pháp Metaclass mới. Thay vì:: New Metaclass Syntax. Instead of:
```
class C:
    __metaclass__ = M
    ...
```
Bây giờ bạn phải sử dụng:
```
class C[metaclass=M]:
    ...
```
Biến mô-đun-Global
```
print["There are  possibilities!", sep=""]
```
85 không còn được hỗ trợ. .
Danh sách các hệ thống không còn hỗ trợ hình thức cú pháp
```
print["There are  possibilities!", sep=""]
```
87. Sử dụng
```
print["There are  possibilities!", sep=""]
```
88 thay thế. Cũng lưu ý rằng các toàn bộ danh sách có ngữ nghĩa khác nhau: chúng gần với đường cú pháp hơn cho biểu thức máy phát bên trong hàm tạo
```
class C:
    __metaclass__ = M
    ...
```
3 và đặc biệt là các biến điều khiển vòng lặp không còn bị rò rỉ vào phạm vi xung quanh.
Ellipsis [
```
print["There are  possibilities!", sep=""]
```
90] có thể được sử dụng như một biểu thức nguyên tử ở bất cứ đâu. [Trước đây nó chỉ được phép trong các lát cắt.] Ngoài ra, bây giờ nó phải được đánh vần là
```
print["There are  possibilities!", sep=""]
```
90. [Trước đây nó cũng có thể được đánh vần là
```
print["There are  possibilities!", sep=""]
```
92, chỉ bằng một tai nạn ngữ pháp.]

Đã xóa cú pháp

PEP 3113: Đã gỡ bỏ tham số tuple. Bạn không còn có thể viết
```
print["There are  possibilities!", sep=""]
```
93. Sử dụng
print["There are possibilities!", sep=""]
94 thay thế.: Tuple parameter unpacking removed. You can no longer write
```
print["There are  possibilities!", sep=""]
```
93. Use
```
print["There are  possibilities!", sep=""]
```
94 instead.
Thay vào đó đã loại bỏ BackTicks [sử dụng print7].

Đã xóa

print["There are  possibilities!", sep=""]

96 [sử dụng

raise SecondaryException[] from primary_exception

7 thay thế].

Từ khóa bị xóa:
```
print["There are  possibilities!", sep=""]
```
98 không còn là từ khóa; Nó vẫn là một chức năng. [May mắn thay, cú pháp chức năng cũng được chấp nhận trong 2.x.] Cũng lưu ý rằng
```
print["There are  possibilities!", sep=""]
```
98 không còn có đối số luồng; Thay vì
```
There are  possibilities!
```
00, bạn có thể sử dụng
```
There are  possibilities!
```
01.
Số nguyên không còn hỗ trợ một dấu vết
```
There are  possibilities!
```
02 hoặc print8.
Chuỗi chữ không còn hỗ trợ hàng đầu
```
There are  possibilities!
```
04 hoặc
```
There are  possibilities!
```
05.
Mô -đun
```
There are  possibilities!
```
06
```
There are  possibilities!
```
07
```
print["There are  possibilities!", sep=""]
```
50 cú pháp chỉ được phép ở cấp độ mô -đun, không còn các hàm bên trong.
Cú pháp duy nhất được chấp nhận cho nhập khẩu tương đối là
```
There are  possibilities!
```
09. Tất cả các biểu mẫu
```
There are  possibilities!
```
07 không bắt đầu với
```
There are  possibilities!
```
11 được hiểu là nhập khẩu tuyệt đối. [PEP 328]PEP 328]
Các lớp học cổ điển đã biến mất.

Những thay đổi đã có trong Python 2.6¶

Vì nhiều người dùng có lẽ thực hiện bước nhảy thẳng từ Python 2.5 đến Python 3.0, phần này nhắc nhở người đọc về các tính năng mới được thiết kế ban đầu cho Python 3.0 nhưng được đặt lại thành Python 2.6. Các phần tương ứng trong những gì mới trong Python 2.6 nên được tư vấn cho các mô tả dài hơn.What’s New in Python 2.6 should be consulted for longer descriptions.

PEP 343: Tuyên bố với câu nói. Tuyên bố
```
print["There are  possibilities!", sep=""]
```
77 hiện là một tính năng tiêu chuẩn và không còn cần phải được nhập từ
```
There are  possibilities!
```
13. Đồng thời kiểm tra viết các nhà quản lý bối cảnh và mô -đun bối cảnh.. The
```
print["There are  possibilities!", sep=""]
```
77 statement is now a standard feature and no longer needs to be imported from the
```
There are  possibilities!
```
13. Also check out Writing Context Managers and The contextlib module.
PEP 366: Nhập khẩu tương đối rõ ràng từ một mô -đun chính. Điều này giúp tăng cường tính hữu ích của tùy chọn
```
There are  possibilities!
```
14 khi mô -đun được tham chiếu sống trong một gói.. This enhances the usefulness of the
```
There are  possibilities!
```
14 option when the referenced module lives in a package.
PEP 370: Thư mục gói trang web của người dùng..
PEP 371: Gói đa xử lý..
PEP 3101: Định dạng chuỗi nâng cao. Lưu ý: Mô tả 2.6 đề cập đến phương pháp
```
There are  possibilities!
```
15 cho cả chuỗi 8 bit và Unicode. Trong 3.0, chỉ loại print[]2 [chuỗi văn bản có hỗ trợ unicode] hỗ trợ phương thức này; Loại print[]3 không. Kế hoạch cuối cùng là biến đây thành API duy nhất cho định dạng chuỗi và bắt đầu không phản đối toán tử
```
There are  possibilities!
```
18 trong Python 3.1.. Note: the 2.6 description mentions the
```
There are  possibilities!
```
15 method for both 8-bit and Unicode strings. In 3.0, only the print[]2 type [text strings with Unicode support] supports this method; the print[]3 type does not. The plan is to eventually make this the only API for string formatting, and to start deprecating the
```
There are  possibilities!
```
18 operator in Python 3.1.
PEP 3105: In như một hàm. Đây bây giờ là một tính năng tiêu chuẩn và không còn cần phải được nhập từ
```
There are  possibilities!
```
13. Thêm chi tiết đã được đưa ra ở trên.. This is now a standard feature and no longer needs to be imported from
```
There are  possibilities!
```
13. More details were given above.

PEP 3110: Thay đổi xử lý ngoại lệ. Cú pháp

print["There are  possibilities!", sep=""]

82 exc

print["There are  possibilities!", sep=""]

76 var hiện là tiêu chuẩn và

print["There are  possibilities!", sep=""]

82 exc, var không còn được hỗ trợ. [Tất nhiên, phần

print["There are  possibilities!", sep=""]

76 VAR vẫn là tùy chọn.]. The

print["There are  possibilities!", sep=""]

82 exc

print["There are  possibilities!", sep=""]

76 var syntax is now standard and

print["There are  possibilities!", sep=""]

82 exc, var is no longer supported. [Of course, the

print["There are  possibilities!", sep=""]

76 var part is still optional.]

PEP 3112: BYTE LITERALS. Ký hiệu theo nghĩa đen của chuỗi print0 [và các biến thể của nó như
```
There are  possibilities!
```
25,
```
There are  possibilities!
```
26 và
```
There are  possibilities!
```
27] hiện tạo ra một loại chữ print[]3.. The print0 string literal notation [and its variants like
```
There are  possibilities!
```
25,
```
There are  possibilities!
```
26, and
```
There are  possibilities!
```
27] now produces a literal of type print[]3.
PEP 3116: Thư viện I/O mới. Mô -đun
```
print["There are  possibilities!", sep=""]
```
45 hiện là cách làm tệp I/O tiêu chuẩn. Hàm
```
print["There are  possibilities!", sep=""]
```
19 tích hợp hiện là bí danh cho
```
There are  possibilities!
```
31 và có thêm mã hóa đối số từ khóa, lỗi, dòng mới và CloseFD. Cũng lưu ý rằng một đối số chế độ không hợp lệ hiện đang tăng
```
There are  possibilities!
```
32, không phải
```
There are  possibilities!
```
33. Đối tượng tệp nhị phân có thể truy cập đối tượng tệp văn bản có thể được truy cập dưới dạng
```
There are  possibilities!
```
34 [nhưng hãy cẩn thận rằng đối tượng văn bản duy trì một bộ đệm của chính nó để tăng tốc độ hoạt động mã hóa và giải mã].. The
```
print["There are  possibilities!", sep=""]
```
45 module is now the standard way of doing file I/O. The built-in
```
print["There are  possibilities!", sep=""]
```
19 function is now an alias for
```
There are  possibilities!
```
31 and has additional keyword arguments encoding, errors, newline and closefd. Also note that an invalid mode argument now raises
```
There are  possibilities!
```
32, not
```
There are  possibilities!
```
33. The binary file object underlying a text file object can be accessed as
```
There are  possibilities!
```
34 [but beware that the text object maintains a buffer of itself in order to speed up the encoding and decoding operations].
PEP 3118: Giao thức bộ đệm sửa đổi. Bản dựng cũ
```
There are  possibilities!
```
35 hiện đã thực sự biến mất; Tương tự mới
```
There are  possibilities!
```
36 cung cấp [hầu hết] chức năng tương tự.. The old builtin
```
There are  possibilities!
```
35 is now really gone; the new builtin
```
There are  possibilities!
```
36 provides [mostly] similar functionality.
PEP 3119: Các lớp cơ sở trừu tượng. Mô-đun
```
There are  possibilities!
```
37 và ABC được xác định trong mô-đun
```
There are  possibilities!
```
38 đóng vai trò nổi bật hơn trong ngôn ngữ hiện nay và các loại thu thập tích hợp như
```
There are  possibilities!
```
1 và
```
There are  possibilities!
```
40 phù hợp với
```
There are  possibilities!
```
41 và
```
print["There are  possibilities!", sep=""]
```
06 ABC.. The
```
There are  possibilities!
```
37 module and the ABCs defined in the
```
There are  possibilities!
```
38 module plays a somewhat more prominent role in the language now, and built-in collection types like
```
There are  possibilities!
```
1 and
```
There are  possibilities!
```
40 conform to the
```
There are  possibilities!
```
41 and
```
print["There are  possibilities!", sep=""]
```
06 ABCs, respectively.
PEP 3127: Hỗ trợ và cú pháp theo nghĩa đen. Như đã đề cập ở trên, ký hiệu theo nghĩa đen mới là một ký hiệu duy nhất được hỗ trợ, và văn học nhị phân đã được thêm vào.. As mentioned above, the new octal literal notation is the only one supported, and binary literals have been added.
PEP 3129: Trang trí lớp..
PEP 3141: Một hệ thống phân cấp loại cho các số. Mô -đun
```
There are  possibilities!
```
43 là một cách sử dụng mới của ABC, xác định Python trong thời gian. Cũng lưu ý mô -đun
```
There are  possibilities!
```
44 mới thực hiện
```
There are  possibilities!
```
45.. The
```
There are  possibilities!
```
43 module is another new use of ABCs, defining Python’s “numeric tower”. Also note the new
```
There are  possibilities!
```
44 module which implements
```
There are  possibilities!
```
45.

Thay đổi thư viện

Do hạn chế về thời gian, tài liệu này không bao gồm các thay đổi rất rộng rãi đối với thư viện tiêu chuẩn. PEP 3108 là tài liệu tham khảo cho các thay đổi chính cho thư viện. Ở đây, một đánh giá viên nang:PEP 3108 is the reference for the major changes to the library. Here’s a capsule review:

Nhiều mô -đun cũ đã được gỡ bỏ. Một số, như
```
There are  possibilities!
```
46 [không còn được sử dụng] và
```
There are  possibilities!
```
47 [được thay thế bằng
```
There are  possibilities!
```
48], đã bị PEP 4. Những người khác bị loại bỏ do việc loại bỏ hỗ trợ cho các nền tảng khác nhau như IRIX, BEOS và Mac OS 9 [xem PEP 11]. Một số mô -đun cũng được chọn để loại bỏ trong Python 3.0 do thiếu sử dụng hoặc do sự thay thế tốt hơn tồn tại. Xem PEP 3108 để biết danh sách đầy đủ.PEP 4. Others were removed as a result of the removal of support for various platforms such as Irix, BeOS and Mac OS 9 [see PEP 11]. Some modules were also selected for removal in Python 3.0 due to lack of use or because a better replacement exists. See PEP 3108 for an exhaustive list.
Gói
```
There are  possibilities!
```
49 đã bị xóa vì sự hiện diện của nó trong thư viện tiêu chuẩn cốt lõi đã được chứng minh theo thời gian là một gánh nặng đặc biệt cho các nhà phát triển cốt lõi do không ổn định thử nghiệm và lịch phát hành của Berkeley DB. Tuy nhiên, gói vẫn còn sống và tốt, được duy trì bên ngoài tại //www.jcea.es/programacion/pybsddb.htm.
Một số mô -đun đã được đổi tên vì tên cũ của họ không tuân theo PEP 8, hoặc vì nhiều lý do khác. Đây là danh sách:PEP 8, or for various other reasons. Here’s the list:

Tên Cu
Tên mới
_winreg

Winreg

Cấu hình

Cấu hình

copy_reg

sao chép

Xếp hàng

xếp hàng

Máy chủ lưu trữ

Máy chủ lưu trữ

Markupbase

_markupbase

repr

reprlib

test.test_support

test.support
Một mẫu phổ biến trong Python 2.x là có một phiên bản của một mô -đun được triển khai trong Pure Python, với phiên bản tăng tốc tùy chọn được triển khai dưới dạng mở rộng C; Ví dụ,
```
There are  possibilities!
```
50 và
```
There are  possibilities!
```
51. Điều này đặt gánh nặng nhập khẩu phiên bản tăng tốc và rơi trở lại trên phiên bản Python thuần túy trên mỗi người dùng của các mô -đun này. Trong Python 3.0, các phiên bản tăng tốc được coi là chi tiết triển khai của các phiên bản Python thuần túy. Người dùng nên luôn luôn nhập phiên bản tiêu chuẩn, cố gắng nhập phiên bản tăng tốc và trở lại phiên bản Python Pure Python. Cặp
```
There are  possibilities!
```
50 /
```
There are  possibilities!
```
51 đã nhận được điều trị này. Mô -đun
```
There are  possibilities!
```
54 nằm trong danh sách cho 3.1. Mô -đun
```
print["There are  possibilities!", sep=""]
```
43 đã được biến thành một lớp trong mô -đun
```
print["There are  possibilities!", sep=""]
```
45.

Một số mô -đun liên quan đã được nhóm thành các gói và thường các tên mô hình con đã được đơn giản hóa. Các gói mới kết quả là:

There are  possibilities!

57 [

There are  possibilities!

58,

There are  possibilities!

59,

There are  possibilities!

57,

There are  possibilities!

61,

There are  possibilities!

62,

There are  possibilities!

63].

There are  possibilities!

64 [

There are  possibilities!

65,

There are  possibilities!

66].

There are  possibilities!

67 [

There are  possibilities!

68,

There are  possibilities!

69,

There are  possibilities!

70,

There are  possibilities!

71,

There are  possibilities!

72,

There are  possibilities!

73].

```
There are  possibilities!
```
74 [tất cả các mô-đun liên quan đến ____ 275 ngoại trừ
```
There are  possibilities!
```
76]. Đối tượng mục tiêu của
```
There are  possibilities!
```
76 không thực sự quan tâm đến
```
There are  possibilities!
```
74. Cũng lưu ý rằng như của Python 2.6, chức năng của
```
There are  possibilities!
```
76 đã được tăng cường đáng kể.

There are  possibilities!

80 [

There are  possibilities!

80,

There are  possibilities!

82,

There are  possibilities!

83,

There are  possibilities!

84].

There are  possibilities!

85 [

There are  possibilities!

86,

There are  possibilities!

87,

There are  possibilities!

88].

Một số thay đổi khác đối với các mô -đun thư viện tiêu chuẩn, không được bao phủ bởi PEP 3108:PEP 3108:

Bị giết

There are  possibilities!

89. Sử dụng lớp

print["There are  possibilities!", sep=""]

64 tích hợp.

Làm sạch mô -đun

There are  possibilities!

91: Đã xóa

There are  possibilities!

92,

There are  possibilities!

93,

There are  possibilities!

94,

There are  possibilities!

95,

There are  possibilities!

96. [Lưu ý rằng

There are  possibilities!

97, v.v.

Làm sạch loại

There are  possibilities!

98: Các phương pháp

There are  possibilities!

99 và

class C:
    __metaclass__ = M
    ...

00 đã biến mất; sử dụng

class C:
    __metaclass__ = M
    ...

01 và

class C:
    __metaclass__ = M
    ...

02 thay thế. Ngoài ra, kiểu chữ

class C:
    __metaclass__ = M
    ...

03 cho mảng đã biến mất - sử dụng

class C:
    __metaclass__ = M
    ...

04 cho byte hoặc

class C:
    __metaclass__ = M
    ...

05 cho các ký tự Unicode.

Làm sạch mô -đun

class C:
    __metaclass__ = M
    ...

06: Đã xóa

class C:
    __metaclass__ = M
    ...

07 và

class C:
    __metaclass__ = M
    ...

08.

Làm sạch mô -đun

class C:
    __metaclass__ = M
    ...

09:

class C:
    __metaclass__ = M
    ...

10 và

class C:
    __metaclass__ = M
    ...

11 đã biến mất; Thay vào đó, sử dụng

class C:
    __metaclass__ = M
    ...

12 và

class C:
    __metaclass__ = M
    ...

13.

Làm sạch mô -đun

class C:
    __metaclass__ = M
    ...

14: Đã xóa API

class C:
    __metaclass__ = M
    ...

15.

Mô -đun
```
class C:
    __metaclass__ = M
    ...
```
16 đã biến mất.

Các chức năng

class C:
    __metaclass__ = M
    ...

17,

class C:
    __metaclass__ = M
    ...

18 và

class C:
    __metaclass__ = M
    ...

19 đã được loại bỏ có lợi cho mô -đun

class C:
    __metaclass__ = M
    ...

20.

Mô -đun
```
class C:
    __metaclass__ = M
    ...
```
21 đã được thay đổi để hoạt động với byte. Điểm nhập chính hiện là
```
class C:
    __metaclass__ = M
    ...
```
22, thay vì tạo_tokens.

class C:
    __metaclass__ = M
    ...

23 và bạn bè của nó [

class C:
    __metaclass__ = M
    ...

24 và

class C:
    __metaclass__ = M
    ...

25] đã biến mất. Sử dụng

class C:
    __metaclass__ = M
    ...

26, vv Thay vào đó. .

Đổi tên mô -đun
```
class C:
    __metaclass__ = M
    ...
```
28 thành
```
class C:
    __metaclass__ = M
    ...
```
29 [loại bỏ các dấu gạch dưới, thêm một s s]. Biến
```
class C:
    __metaclass__ = M
    ...
```
30 được tìm thấy trong hầu hết các không gian tên toàn cầu là không thay đổi. Để sửa đổi một tích hợp, bạn nên sử dụng
```
class C:
    __metaclass__ = M
    ...
```
29, không phải
```
class C:
    __metaclass__ = M
    ...
```
30!

PEP 3101: Một cách tiếp cận mới đối với định dạng chuỗi: A New Approach To String Formatting¶

Một hệ thống mới cho các hoạt động định dạng chuỗi tích hợp thay thế toán tử định dạng chuỗi
```
There are  possibilities!
```
18. .PEP 3101 for the full scoop.

Thay đổi về ngoại lệ

Các API để tăng và ngoại lệ đã được làm sạch và các tính năng mạnh mẽ mới được thêm vào:

PEP 352: Tất cả các trường hợp ngoại lệ phải được bắt nguồn [trực tiếp hoặc gián tiếp] từ
```
class C:
    __metaclass__ = M
    ...
```
35. Đây là gốc của hệ thống phân cấp ngoại lệ. Đây không phải là một khuyến nghị mới, nhưng yêu cầu thừa kế từ
class C: __metaclass__ = M ...
35 là mới. .: All exceptions must be derived [directly or indirectly] from
```
class C:
    __metaclass__ = M
    ...
```
35. This is the root of the exception hierarchy. This is not new as a recommendation, but the requirement to inherit from
```
class C:
    __metaclass__ = M
    ...
```
35 is new. [Python 2.6 still allowed classic classes to be raised, and placed no restriction on what you can catch.] As a consequence, string exceptions are finally truly and utterly dead.
Hầu như tất cả các trường hợp ngoại lệ thực sự sẽ xuất phát từ
```
class C:
    __metaclass__ = M
    ...
```
37;
```
class C:
    __metaclass__ = M
    ...
```
35 chỉ nên được sử dụng làm lớp cơ sở cho các trường hợp ngoại lệ chỉ nên được xử lý ở cấp cao nhất, chẳng hạn như
```
class C:
    __metaclass__ = M
    ...
```
39 hoặc
```
class C:
    __metaclass__ = M
    ...
```
40. Thành ngữ được đề xuất để xử lý tất cả các ngoại lệ ngoại trừ danh mục sau này là sử dụng
```
print["There are  possibilities!", sep=""]
```
82
```
class C:
    __metaclass__ = M
    ...
```
37.
```
class C:
    __metaclass__ = M
    ...
```
43 đã được gỡ bỏ.
Ngoại lệ không còn hoạt động như trình tự. Sử dụng thuộc tính
```
class C:
    __metaclass__ = M
    ...
```
44 thay thế.
PEP 3109: Tăng ngoại lệ. Bây giờ bạn phải sử dụng
```
class C:
    __metaclass__ = M
    ...
```
45 thay vì
class C: __metaclass__ = M ...
46. Ngoài ra, bạn không còn có thể chỉ định rõ ràng một dấu vết; Thay vào đó, nếu bạn phải làm điều này, bạn có thể gán trực tiếp cho thuộc tính
class C: __metaclass__ = M ...
47 [xem bên dưới].: Raising exceptions. You must now use
```
class C:
    __metaclass__ = M
    ...
```
45 instead of
```
class C:
    __metaclass__ = M
    ...
```
46. Additionally, you can no longer explicitly specify a traceback; instead, if you have to do this, you can assign directly to the
```
class C:
    __metaclass__ = M
    ...
```
47 attribute [see below].

PEP 3110: Bắt các ngoại lệ. Bây giờ bạn phải sử dụng

class C:
    __metaclass__ = M
    ...

48 thay vì
class C: __metaclass__ = M ...
49. Hơn nữa, biến bị xóa rõ ràng khi khối
print["There are possibilities!", sep=""]
82 bị bỏ lại.: Catching exceptions. You must now use

class C:
    __metaclass__ = M
    ...

48 instead of

class C:
    __metaclass__ = M
    ...

49. Moreover, the variable is explicitly deleted when the

print["There are  possibilities!", sep=""]

82 block is left.

PEP 3134: Chuỗi ngoại lệ. Có hai trường hợp: chuỗi ngầm và chuỗi rõ ràng. Chuỗi tiềm ẩn xảy ra khi một ngoại lệ được nâng lên trong khối xử lý
```
print["There are  possibilities!", sep=""]
```
82 hoặc
class C: __metaclass__ = M ...
52. Điều này thường xảy ra do một lỗi trong khối xử lý; Chúng tôi gọi đây là một ngoại lệ thứ cấp. Trong trường hợp này, ngoại lệ ban đầu [đã được xử lý] được lưu dưới dạng thuộc tính
class C: __metaclass__ = M ...
53 của ngoại lệ thứ cấp. Chuỗi rõ ràng được gọi bằng cú pháp này:: Exception chaining. There are two cases: implicit chaining and explicit chaining. Implicit chaining happens when an exception is raised in an
```
print["There are  possibilities!", sep=""]
```
82 or
```
class C:
    __metaclass__ = M
    ...
```
52 handler block. This usually happens due to a bug in the handler block; we call this a secondary exception. In this case, the original exception [that was being handled] is saved as the
```
class C:
    __metaclass__ = M
    ...
```
53 attribute of the secondary exception. Explicit chaining is invoked with this syntax:
```
raise SecondaryException[] from primary_exception
```
. Trong trường hợp này, ngoại lệ chính được lưu trữ trên thuộc tính
```
class C:
    __metaclass__ = M
    ...
```
54 của ngoại lệ thứ cấp. TraceBack được in khi một ngoại lệ chưa được xử lý xảy ra trên chuỗi các thuộc tính
```
class C:
    __metaclass__ = M
    ...
```
54 và
```
class C:
    __metaclass__ = M
    ...
```
53 và in một dấu vết riêng cho từng thành phần của chuỗi, với ngoại lệ chính ở trên cùng. [Người dùng Java có thể nhận ra hành vi này.]
PEP 3134: Các đối tượng ngoại lệ hiện lưu trữ dấu vết của họ dưới dạng thuộc tính
```
class C:
    __metaclass__ = M
    ...
```
47. Điều này có nghĩa là một đối tượng ngoại lệ hiện chứa tất cả các thông tin liên quan đến một ngoại lệ và có ít lý do hơn để sử dụng
class C: __metaclass__ = M ...
58 [mặc dù sau này không bị xóa].: Exception objects now store their traceback as the
```
class C:
    __metaclass__ = M
    ...
```
47 attribute. This means that an exception object now contains all the information pertaining to an exception, and there are fewer reasons to use
```
class C:
    __metaclass__ = M
    ...
```
58 [though the latter is not removed].
Một vài tin nhắn ngoại lệ được cải thiện khi Windows không tải mô -đun mở rộng. Ví dụ,
```
class C:
    __metaclass__ = M
    ...
```
59 hiện là
```
class C:
    __metaclass__ = M
    ...
```
60. Các chuỗi bây giờ đối phó với các địa phương không phải là tiếng Anh.

Những thay đổi khác về các thay đổi khác

Người vận hành và phương pháp đặc biệt

raise SecondaryException[] from primary_exception

7 Bây giờ trả về đối diện

raise SecondaryException[] from primary_exception

6, trừ khi

raise SecondaryException[] from primary_exception

6 trả về

class C:
    __metaclass__ = M
    ...

64.

Khái niệm về các phương pháp không liên kết của người Viking đã bị xóa khỏi ngôn ngữ. Khi tham chiếu một phương thức làm thuộc tính lớp, giờ đây bạn sẽ nhận được một đối tượng hàm đơn giản.

class C:
    __metaclass__ = M
    ...

65,

class C:
    __metaclass__ = M
    ...

66 và

class C:
    __metaclass__ = M
    ...

67 đã bị giết. Cú pháp

class C:
    __metaclass__ = M
    ...

68 hiện chuyển thành

class C:
    __metaclass__ = M
    ...

69 [hoặc

class C:
    __metaclass__ = M
    ...

70 hoặc

class C:
    __metaclass__ = M
    ...

71, khi được sử dụng như một mục tiêu phân công hoặc xóa, tương ứng].

PEP 3114: Phương pháp

class C:
    __metaclass__ = M
    ...

72 tiêu chuẩn đã được đổi tên thành
class C: __metaclass__ = M ...
73.: the standard

class C:
    __metaclass__ = M
    ...

72 method has been renamed to

class C:
    __metaclass__ = M
    ...

73.

Các phương pháp đặc biệt

class C:
    __metaclass__ = M
    ...

74 và

class C:
    __metaclass__ = M
    ...

75 đã bị xóa -

class C:
    __metaclass__ = M
    ...

76 và

class C:
    __metaclass__ = M
    ...

77 Sử dụng

class C:
    __metaclass__ = M
    ...

78 Bây giờ để chuyển đổi đối số thành số nguyên.

Đã loại bỏ hỗ trợ cho

class C:
    __metaclass__ = M
    ...

79 và

class C:
    __metaclass__ = M
    ...

80.

Các thuộc tính hàm có tên

class C:
    __metaclass__ = M
    ...

81 đã được đổi tên để sử dụng biểu mẫu

class C:
    __metaclass__ = M
    ...

82, giải phóng các tên này trong không gian tên thuộc tính hàm cho các thuộc tính do người dùng xác định. Để dí dỏm,

class C:
    __metaclass__ = M
    ...

83,

class C:
    __metaclass__ = M
    ...

84,

class C:
    __metaclass__ = M
    ...

85,

class C:
    __metaclass__ = M
    ...

86,

class C:
    __metaclass__ = M
    ...

87,

class C:
    __metaclass__ = M
    ...

88,

class C:
    __metaclass__ = M
    ...

89 được đổi tên thành

class C:
    __metaclass__ = M
    ...

90,

class C:
    __metaclass__ = M
    ...

91,

class C:
    __metaclass__ = M
    ...

92, ____.

class C:
    __metaclass__ = M
    ...

97 bây giờ là

class C:
    __metaclass__ = M
    ...

98.

Tuiolognins¶

PEP 3135: Mới
```
class C:
    __metaclass__ = M
    ...
```
99. Bây giờ bạn có thể gọi
class C: __metaclass__ = M ...
99 mà không có đối số và [giả sử đây là trong một phương thức thể hiện thông thường được xác định bên trong câu lệnh
class C[metaclass=M]: ...
01] lớp bên phải và thể hiện sẽ tự động được chọn. Với các lập luận, hành vi của
class C: __metaclass__ = M ...
99 không thay đổi.: New
```
class C:
    __metaclass__ = M
    ...
```
99. You can now invoke
```
class C:
    __metaclass__ = M
    ...
```
99 without arguments and [assuming this is in a regular instance method defined inside a
```
class C[metaclass=M]:
    ...
```
01 statement] the right class and instance will automatically be chosen. With arguments, the behavior of
```
class C:
    __metaclass__ = M
    ...
```
99 is unchanged.

PEP 3111:

class C[metaclass=M]:
    ...

03 được đổi tên thành
class C[metaclass=M]: ...
04. Đó là, chức năng
class C[metaclass=M]: ...
04 mới đọc một dòng từ
print["There are possibilities!", sep=""]
23 và trả về nó với dòng mới bị loại bỏ. Nó tăng
class C[metaclass=M]: ...
07 nếu đầu vào bị chấm dứt sớm. Để có được hành vi cũ của
class C[metaclass=M]: ...
04, hãy sử dụng
class C[metaclass=M]: ...
09.:

class C[metaclass=M]:
    ...

03 was renamed to

class C[metaclass=M]:
    ...

04. That is, the new

class C[metaclass=M]:
    ...

04 function reads a line from

print["There are  possibilities!", sep=""]

23 and returns it with the trailing newline stripped. It raises

class C[metaclass=M]:
    ...

07 if the input is terminated prematurely. To get the old behavior of

class C[metaclass=M]:
    ...

04, use

class C[metaclass=M]:
    ...

09.

Một hàm tích hợp mới
```
class C:
    __metaclass__ = M
    ...
```
72 đã được thêm vào để gọi phương thức
```
class C:
    __metaclass__ = M
    ...
```
73 trên một đối tượng.
Chiến lược làm tròn chức năng
```
class C[metaclass=M]:
    ...
```
12 đã thay đổi. Các trường hợp nửa chừng chính xác hiện được làm tròn đến kết quả thậm chí gần nhất thay vì cách xa số không. . Nó thường trả về một số nguyên khi được gọi với một đối số duy nhất và giá trị cùng loại với
```
class C[metaclass=M]:
    ...
```
18 khi được gọi với hai đối số.

Chuyển

class C[metaclass=M]:
    ...

19 sang

class C[metaclass=M]:
    ...

20.

Đã loại bỏ:

class C[metaclass=M]:
    ...

21. Thay vì

class C[metaclass=M]:
    ...

22 sử dụng

class C[metaclass=M]:
    ...

23.

Đã loại bỏ

class C[metaclass=M]:
    ...

24. Thay vì

class C[metaclass=M]:
    ...

25, bạn có thể sử dụng

class C[metaclass=M]:
    ...

26. Hàm

class C[metaclass=M]:
    ...

27 cũng biến mất.

Đã loại bỏ
```
class C[metaclass=M]:
    ...
```
28. Chức năng này không còn phục vụ một mục đích bây giờ là các lớp cổ điển đã biến mất.

Đã loại bỏ

class C[metaclass=M]:
    ...

29. Thay vì

class C[metaclass=M]:
    ...

30 sử dụng

class C[metaclass=M]:
    ...

31.

Đã loại bỏ loại
```
class C[metaclass=M]:
    ...
```
32. Sử dụng
```
print["There are  possibilities!", sep=""]
```
19. Hiện tại có một số loại luồng khác nhau mở có thể quay lại trong mô -đun
```
print["There are  possibilities!", sep=""]
```
45.
Đã loại bỏ
```
class C[metaclass=M]:
    ...
```
35. Sử dụng
```
class C[metaclass=M]:
    ...
```
36 nếu bạn thực sự cần nó; Tuy nhiên, 99 phần trăm thời gian một vòng lặp
```
class C:
    __metaclass__ = M
    ...
```
7 rõ ràng là dễ đọc hơn.

Đã loại bỏ

class C[metaclass=M]:
    ...

38. Sử dụng

class C[metaclass=M]:
    ...

39.

Loại bỏ.

class C[metaclass=M]:
    ...

40 - sử dụng toán tử

class C[metaclass=M]:
    ...

41 thay thế.

Xây dựng và C API thay đổi Or

Do các hạn chế về thời gian, đây là một danh sách rất không đầy đủ các thay đổi đối với API C.

Hỗ trợ cho một số nền tảng đã bị loại bỏ, bao gồm nhưng không giới hạn ở Mac OS 9, BEOS, RISCOS, IRIX và Tru64.
PEP 3118: API bộ đệm mới.: New Buffer API.
PEP 3121: Khởi tạo và hoàn thiện mô -đun mở rộng.: Extension Module Initialization & Finalization.
PEP 3123: Làm cho
```
class C[metaclass=M]:
    ...
```
42 phù hợp với tiêu chuẩn C.: Making
```
class C[metaclass=M]:
    ...
```
42 conform to standard C.
Không còn hỗ trợ API C để thực hiện hạn chế.

class C[metaclass=M]:
    ...

43,

class C[metaclass=M]:
    ...

44,

class C[metaclass=M]:
    ...

45 và

class C[metaclass=M]:
    ...

46 C API bị xóa.

C API
```
class C[metaclass=M]:
    ...
```
47 mới, hoạt động như
```
class C[metaclass=M]:
    ...
```
48 nhưng đã giành được khối trên khóa nhập [thay vào đó trả lại lỗi].
Được đổi tên thành khe và phương thức cấp độ C cấp độ Bolean:
```
class C[metaclass=M]:
    ...
```
49 hiện là
```
class C[metaclass=M]:
    ...
```
50.

Đã xóa

class C[metaclass=M]:
    ...

51 và

class C[metaclass=M]:
    ...

52 khỏi API C.

Màn biểu diễn¶

Kết quả ròng của các khái quát 3.0 là Python 3.0 chạy điểm chuẩn Pystone chậm hơn khoảng 10% so với Python 2.5. Nhiều khả năng là nguyên nhân lớn nhất là loại bỏ các phần đặc biệt cho các số nguyên nhỏ. Có phòng để cải thiện, nhưng nó sẽ xảy ra sau khi 3.0 được phát hành!

Chuyển sang Python 3.0¶

Để chuyển mã nguồn Python 2.5 hoặc 2.6 hiện tại sang Python 3.0, chiến lược tốt nhất là như sau:

[Điều kiện tiên quyết :] Bắt đầu với phạm vi kiểm tra tuyệt vời.
Cổng đến Python 2.6. Điều này sẽ không hoạt động nhiều hơn cổng trung bình từ Python 2.x đến Python 2. [x+1]. Hãy chắc chắn rằng tất cả các bài kiểm tra của bạn vượt qua.
[Vẫn sử dụng 2.6 :] Bật công tắc dòng lệnh
```
class C[metaclass=M]:
    ...
```
53. Điều này cho phép cảnh báo về các tính năng sẽ bị xóa [hoặc thay đổi] trong 3.0. Chạy lại bộ kiểm tra của bạn và sửa mã mà bạn nhận được cảnh báo cho đến khi không còn cảnh báo và tất cả các bài kiểm tra của bạn vẫn vượt qua.
Chạy trình dịch
```
print["There are  possibilities!", sep=""]
```
8 Nguồn đến nguồn qua cây mã nguồn của bạn. . Khắc phục thủ công mọi vấn đề còn lại, khắc phục sự cố cho đến khi tất cả các bài kiểm tra lại vượt qua.2to3 — Automated Python 2 to 3 code translation for more on this tool.] Run the result of the translation under Python 3.0. Manually fix up any remaining issues, fixing problems until all tests pass again.

Không nên cố gắng viết mã nguồn chạy không thay đổi dưới cả Python 2.6 và 3.0; Bạn phải sử dụng một kiểu mã hóa rất mâu thuẫn, ví dụ: Tránh các câu print, metaclass, và nhiều hơn nữa. Nếu bạn đang duy trì một thư viện cần hỗ trợ cả Python 2.6 và Python 3.0, cách tiếp cận tốt nhất là sửa đổi bước 3 ở trên bằng cách chỉnh sửa phiên bản 2.6 của mã nguồn và chạy lại trình dịch

print["There are  possibilities!", sep=""]

8, thay vì chỉnh sửa phiên bản 3.0 của mã nguồn.

Để chuyển các tiện ích mở rộng C sang Python 3.0, vui lòng xem các mô -đun mở rộng chuyển sang Python 3.Porting Extension Modules to Python 3.

Làm thế nào là in khác nhau trong Python 3?

Trong Python 2, in là một tuyên bố không cần dấu ngoặc đơn.Trong Python 3, in là một hàm và các giá trị cần được viết trong ngoặc đơn.print is a function and the values need to be written in parenthesis.

Tại sao in không phải là một chức năng trong Python 2?

In là một tuyên bố trong Python vì đó là một tuyên bố trong ABC, nguồn cảm hứng chính cho Python [mặc dù nó được gọi là viết ở đó].Điều đó có lẽ đã có một tuyên bố thay vì một chức năng vì nó là ngôn ngữ giảng dạy và như vậy được truyền cảm hứng từ cơ bản. [although it was called WRITE there]. That in turn probably had a statement instead of a function as it was a teaching language and as such inspired by basic.

Có phải in một chức năng tích hợp trong Python?

Chức năng tích hợp Python..

print [] chức năng ..

loại [] hàm ..

chức năng đầu vào [] ..

chức năng abs [] ..

chức năng pow [] ..

chức năng dir [] ..

Sắp xếp [] chức năng ..

hàm tối đa [] ..

Sự khác biệt giữa Python 2 và Python 3 là gì?

Python 3 có cú pháp dễ dàng hơn so với Python 2. Rất nhiều thư viện của Python 2 không tương thích về phía trước.Rất nhiều thư viện được tạo ra trong Python 3 để được sử dụng nghiêm ngặt với Python 3. Python 2 không còn được sử dụng kể từ năm 2020.. A lot of libraries of Python 2 are not forward compatible. A lot of libraries are created in Python 3 to be strictly used with Python 3. Python 2 is no longer in use since 2020.

_winreg	Winreg
Cấu hình	Cấu hình
copy_reg	sao chép
Xếp hàng	xếp hàng
Máy chủ lưu trữ	Máy chủ lưu trữ
Markupbase	_markupbase
repr	reprlib
test.test_support	test.support

Vấp ngã thông thường

In là một chức năng

Lượt xem và lặp lại thay vì danh sách

Đặt hàng so sánh Jo

Số nguyên

Văn bản Vs. Dữ liệu thay vì Unicode Vs. 8 bit¶

Tổng quan về các thay đổi cú pháp

Cú pháp mới

Đã thay đổi cú pháp

Đã xóa cú pháp

Những thay đổi đã có trong Python 2.6¶

Thay đổi thư viện

PEP 3101: Một cách tiếp cận mới đối với định dạng chuỗi: A New Approach To String Formatting¶

Thay đổi về ngoại lệ

Những thay đổi khác về các thay đổi khác

Người vận hành và phương pháp đặc biệt

Tuiolognins¶

Xây dựng và C API thay đổi Or

Màn biểu diễn¶

Chuyển sang Python 3.0¶

Làm thế nào là in khác nhau trong Python 3?

Tại sao in không phải là một chức năng trong Python 2?

Có phải in một chức năng tích hợp trong Python?

Sự khác biệt giữa Python 2 và Python 3 là gì?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề