Hầu như tất cả các chương trình Python 2 đều cần một số sửa đổi để hoạt động bình thường trong môi trường Python 3. Để đơn giản hóa quá trình chuyển đổi này, Python 3 tự đi kèm với một kịch bản tiện ích gọi là 2to3 (Utility Script), kịch bản này sẽ lấy tệp nguồn chương trình Python 2 của bạn làm đầu vào và sau đó tự động chuyển đổi nó thành Python 3. Nghiên cứu trường hợp: Chuyển chardet sang Python 3 (porting chardet to Python 3) mô tả cách chạy kịch bản này và sau đó cho thấy một số trường hợp mà nó không thể tự động sửa chữa.
Trong Python 2, print là một câu lệnh. Bất cứ điều gì bạn muốn xuất, bạn chỉ cần đặt chúng sau từ khóa print. Trong Python 3, print ((() là một hàm. Giống như các hàm khác, print (()) đòi hỏi bạn sẽ xuất những gì bạn muốn như một tham số.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | in | print ((() |
| ② | in 1 | print ((1) |
| ③ | 1,2 in | print ((1,2) |
| ④ | in 1, 2, | print ((1,2,end= |
| ⑤ | print >>sys.stderr,1,2,3 | print ((1,2,3, file=sys.stderr) |
1, Để xuất một dòng trống, bạn cần gọi print không có tham số (((((().
2, Để xuất một giá trị riêng biệt, bạn cần phải sử dụng giá trị này như là một trong các tham số print ().
3, để xuất sử dụng hai giá trị được tách ra bởi một không gian, bạn có thể gọi print ((() bằng hai tham số.
Ví dụ này có một số thủ thuật. Trong Python 2, nếu bạn sử dụng dấu chấm (*) như là kết thúc của câu lệnh print, nó sẽ xuất ra kết quả bằng cách tách khoảng trống, sau đó xuất ra một khoảng trống kéo theo (trailing space) mà không xuất ra xe tải (carriage return). Trong Python 3, hiệu quả tương tự có thể đạt được bằng cách truyền end=
Python 2 có hai kiểu chuỗi:Dòng UnicodevàDây không Unicode◎ Python 3 chỉ có một kiểu:Các chuỗi Unicode。
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | ||
| ② | ur |
r |
Các chuỗi Unicode trong Python 2 là các chuỗi thông thường trong Python 3, vì trong Python 3 các chuỗi luôn có dạng Unicode. Dấu hiệu của các chuỗi nguyên gốc Unicode (raw string) (bằng cách sử dụng chuỗi này, Python sẽ không tự động chuyển nghĩa ngược đường nghiêng") cũng được thay thế thành các chuỗi thông thường, vì trong Python 3, tất cả các chuỗi nguyên gốc được mã hóa bằng Unicode.
Python 2 có hai hàm toàn cầu có thể buộc các đối tượng được chuyển đổi thành các chuỗi: unicode (() chuyển đổi đối tượng thành các chuỗi Unicode, và str (()) chuyển đổi đối tượng thành các chuỗi phi Unicode. Python 3 chỉ có một loại chuỗi, một chuỗi Unicode, vì vậy hàm str (()) hoàn thành tất cả các chức năng.Các chức năng unicode ((() không còn tồn tại trong Python 3.)
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | Unicode ((bất cứ điều gì) | Str (((bất cứ điều gì) |
Python 2 có các kiểu int và long được chuẩn bị cho các số không phơi phơi. Giá trị tối đa của kiểu int không thể vượt quá sys.maxint, và giá trị tối đa này có liên quan đến nền tảng. Các kiểu tổng thể dài có thể được xác định bằng cách thêm một L vào cuối số, rõ ràng là nó có phạm vi số lớn hơn so với kiểu int. Trong Python 3, chỉ có một kiểu tổng thể int, trong hầu hết các trường hợp, nó giống như kiểu tổng thể dài trong Python 2. Vì không có các kiểu tổng thể, không cần phải sử dụng ngữ pháp đặc biệt để phân biệt chúng.
Đọc thêm: PEP 237: thống nhất các dạng tổng thể và tổng thể.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | x = 1000000000000L | x = 1000000000000 |
| ② | x = 0xFFFFFFFFFFFF | x = 0xFFFFFFFFFFFF |
| ③ | dài ((x) | int ((x) |
| ④ | type(x) là dài | type ((x) là int |
| ⑤ | isinstance ((x,long) | isinstance ((x,int) |
Trong Python 2, dạng nguyên tố dài thập phân được thay thế bằng số nguyên tố thông thường thập phân trong Python 3. Trong Python 2, các con số nguyên tố dài 16 chữ số được thay thế bằng các con số nguyên tố đơn giản 16 chữ số trong Python 3. Trong Python 3, các kiểu dài không còn tồn tại nữa.Chức năng long ((()) tự nhiên cũng không còn. Để ép chuyển đổi một biến thành kiểu nguyên, bạn có thể sử dụng hàm int ((().‖ Kiểm tra xem một biến là nguyên, lấy kiểu dữ liệu của nó và so sánh với kiểu int (không phải dài). Bạn cũng có thể sử dụng chức năng istance () để kiểm tra kiểu dữ liệu; một lần nữa nhấn mạnh, sử dụng int, chứ không phải long, để kiểm tra kiểu số nguyên.
Python 2 hỗ trợ <> như một từ đồng nghĩa với!=. Python 3 chỉ hỗ trợ!=, không còn hỗ trợ <>.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | nếu x <> y: | nếu x!= y: |
| ② | nếu x <> y <> z: | nếu x!= y!= z: |
1, đơn giản so sánh. 2, so sánh giữa ba giá trị tương đối phức tạp.
Trong Python 2, phương pháp has_key của đối tượng từ điển được sử dụng để kiểm tra liệu từ điển có chứa một khóa cụ thể hay không. Python 3 không hỗ trợ phương pháp này nữa. Bạn cần sử dụngtrongCác toán tử.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | a_dictionary.has_key (( |
|
| ② | a_dictionary.has_key ((x) hoặc a_dictionary.has_key ((y) | x trong từ điển hoặc y trong từ điển |
| ③ | a_dictionary.has_key ((x hoặc y) | (x hoặc y) trong từ điển |
| ④ | a_dictionary.has_key ((x + y) | (x + y) trong a_dictionary |
| ⑤ | x + a_dictionary.has_key ((y)) | x + (y trong từ điển) |
Một, hình thức đơn giản nhất.
2, các ký hiệu của or có ưu tiên thấp hơn ký hiệu của in, do đó không cần thêm dấu ngoặc.
3, Mặt khác, vì cùng một lý do, ưu tiên của
Trong Python 2, nhiều phương thức từ điển trả về các danh sách. Trong đó, các phương thức thường được sử dụng nhất là các khóa, item và value. Trong Python 3, tất cả các phương pháp trả về các giá trị được thay đổi thành dynamic view. Trong một số môi trường ngữ cảnh, sự thay đổi này không có tác động. Nếu các giá trị trả về của các phương pháp được chuyển ngay đến một hàm khác và hàm đó đi qua toàn bộ chuỗi, thì các giá trị trả về của các phương pháp đó là danh sách hoặc view sẽ không thay đổi và tạo ra bất kỳ sự khác biệt nào.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | a_dictionary.keys() | list ((a_dictionary.keys()) |
| ② | a_dictionary.items (tạm dịch: từ điển) | danh sách ((a_dictionary.items()) |
| ③ | a_dictionary.iterkeys() | iter ((a_dictionary.keys()) |
| ④ | [i for iin a_dictionary.iterkeys() ] | [i for iin a_dictionary.keys() ] |
| ⑤ | min(a_dictionary.keys()) | không thay đổi |
1, sử dụng list () hàm chuyển đổi giá trị trả về của keys () thành một danh sách tĩnh, vì lý do an ninh, 2to3 có thể trả lại lỗi. Mã như vậy có hiệu quả, nhưng nó có hiệu quả thấp hơn đối với việc sử dụng view. Bạn nên kiểm tra mã sau khi chuyển đổi để xem liệu bạn có cần một danh sách, và có lẽ view cũng có thể làm được điều tương tự. 2, đây là một cách khác để xem chuyển đổi của phương pháp (về các mục)) đến danh sách. 3, không còn hỗ trợ các iterkeys trong Python 3. Nếu cần thiết, hãy sử dụng iter để chuyển đổi giá trị trả lại của keys thành một iterator. 4, 2to3 có thể nhận ra các phương pháp iterkeys được sử dụng trong phân tích danh sách và sau đó chuyển đổi nó thành keys trong Python 3. 5, 2to3 cũng có thể xác định các phương thức keys (() mà giá trị trả về được chuyển ngay đến một hàm khác sẽ đi qua toàn bộ chuỗi, do đó không cần phải chuyển đổi giá trị trả về của keys (() sang một danh sách trước. Ngược lại, hàm min (()) sẽ vui lòng đi qua các dạng xem. Quá trình này cũng hiệu quả đối với min ((), max ((), sum ((), tuple ((), setlist ((), sorted ((), any (() và all (()).
Một số mô-đun trong thư viện tiêu chuẩn từ Python 2 đến Python 3 đã được đổi tên. Một số mô-đun liên kết với nhau cũng được kết hợp hoặc tổ chức lại để làm cho mối liên hệ này hợp lý hơn.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | nhập httplib | nhập http.client |
| ② | Import Cookie | nhập http.cookies |
| ③ | nhập cookielib | nhập http.cookiejar |
| ④ | nhập BaseHTTPServer nhập SimpleHTTPServer nhập CGIHttpServer |
nhập http.server |
Các mô-đun http.client thực hiện một thư viện dưới tầng mà có thể được sử dụng để yêu cầu tài nguyên HTTP và phân tích các phản hồi HTTP. Các phần tử http.cookies cung cấp một giao diện Python để lấy các cookie được gửi qua đầu trang HTTP Set-Cookie Các trình duyệt phổ biến thường lưu trữ cookie dưới dạng tệp trên đĩa, mà các mô-đun http.cookiejar có thể xử lý các tệp này. HTTP.server module thực hiện một máy chủ HTTP cơ bản
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | nhập urllib | nhập urllib.request urllib.parse,urllib.error |
| ② | nhập urllib2 | nhập urllib.request urllib.error |
| ③ | nhập urlparse | nhập urllib.parse |
| ④ | nhập robotparser | nhập urllib.robotparser |
| ⑤ | từ urllib import FancyURLopener từ urllib import urlencode |
từ urllib.request nhập FancyURLopener từ urllib.parse nhập urlencode |
| ⑥ | từ urllib2 import Yêu cầu từ urllib2 import HTTPError |
từ urllib.request import Request từ urllib.error import HTTPError |
Trước đây, các module urllib trong Python 2 có nhiều chức năng khác nhau, bao gồm urlopen để lấy dữ liệu, và cũng hữu ích để chia URL thành các chức năng splittype, splithost và splituser. Trong gói urllib mới, các chức năng này được tổ chức hợp lý hơn. Trong Python 3, các mô-đun urllib2 trước đây đã được tích hợp vào gói urllib. Trong khi đó, trong urllib2, nhiều thứ bạn yêu thích sẽ xuất hiện một cách không thể thiếu trong các mô-đun urllib của Python 3, chẳng hạn như phương pháp build_opener, Request object, HTTPBasicAuthHandler và friends. Urllib.parse trong Python 3 chứa tất cả các hàm phân tích trong urlparse trong Python 2. urllib.robotparse module phân tích file robots.txt. Các lớp FancyURLopener xử lý chuyển hướng HTTP và các mã trạng thái khác vẫn hoạt động trong module urllib.request trong Python 3. Object Request vẫn có hiệu lực trong urllib.request, nhưng các hằng số như HTTPError đã được chuyển sang urllib.error. Tôi có đề cập đến 2to3 sẽ viết lại các cuộc gọi của bạn không? Ví dụ, nếu bạn nhập một module urllib trong mã Python 2 và gọi urllib.urlopen (,) để lấy dữ liệu, 2to3 sẽ thay đổi cả import statement và function call.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | import urllib print urllib.urlopen ((()http://diveintopython3.org/’) đọc)) | nhập urllib.request, urllib.parse, urllib.error print ((urllib.request.urlopen)) "http://diveintopython3.org/’) đọc)) |
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | nhập dbm | nhập dbm.ndbm |
| ② | nhập gdbm | nhập khẩudbm.gnu |
| ③ | nhập dbhash | nhập dbm.bsd |
| ④ | nhập dumbdbm | nhập dbm.dumb |
| ⑤ | nhập bất cứ gì nhập bất kỳ gì | nhập dbm |
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | nhập xmlrpclib | nhập xmlrpc.client |
| ② | nhập DocXMLRPCServer nhập SimpleXMLRPCServer |
nhập xmlrpc.server |
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | thử: nhập cStringIO như StringIO trừ ImportError: nhập StringIO |
nhập khẩu |
| ② | try: import cPickle như là dưa chuột except ImportError: import dưa chuột |
dưa chua nhập khẩu |
| ③ | nhập _xây dựng | nhập khẩu |
| ④ | nhập copy_reg | import copyreg |
| ⑤ | Dòng đợi nhập | hàng đợi nhập khẩu |
| ⑥ | nhập SocketServer | nhập socketserver |
| ⑦ | nhập ConfigParser | Import configparser |
| ⑧ | nhập khẩu | nhập reprlib |
| ⑨ | lệnh nhập | Tiến trình phụ nhập khẩu |
1, trong Python 2, bạn thường làm như vậy, trước tiên hãy thử nhập cStringIO làm thay thế cho StringIO, nếu không, hãy nhập lại StringIO. Đừng làm như vậy trong Python 3; mô-đun io sẽ giúp bạn xử lý vấn đề này. Nó sẽ tìm ra cách triển khai nhanh nhất có sẵn và sử dụng nó tự động. Trong Python 2, nhập thực hiện pickle nhanh nhất cũng là một cách tương tự như trên. Trong Python 3, các mô-đun pickle sẽ tự động xử lý cho bạn, vì vậy đừng làm như vậy nữa. 3. Builtins module chứa các hàm, lớp và hằng số toàn cầu được sử dụng trong toàn bộ ngôn ngữ Python. Một hàm trong builtins module được định nghĩa lại có nghĩa là nó được định nghĩa lại ở mọi nơi. Điều này nghe có vẻ mạnh mẽ, nhưng cũng đáng sợ. 4, mô-đun copyreg thêm hỗ trợ cho mô-đun pickle cho các kiểu tùy chỉnh người dùng được định nghĩa bằng ngôn ngữ C. 5, queue module thực hiện một queue người tiêu dùng sản xuất (multi-producer, multi-consumer queue). 6. Socketserver module cung cấp các lớp cơ bản chung để thực hiện các máy chủ socket khác nhau. 7, mô-đun configparser được sử dụng để phân tích các hồ sơ INI-style. 8, reprlib module tái thực hiện chức năng repr () tích hợp và thêm kiểm soát về chiều dài trước khi cắt các ký tự. Các mô-đun subprocess cho phép bạn tạo các subprocess, kết nối với các đường ống của chúng và lấy giá trị trả về của chúng.
Một gói là một thực thể duy nhất được tạo thành từ một tập hợp các mô-đun liên quan. Trong Python 2, để thực hiện tham chiếu lẫn nhau của các mô-đun trong cùng một gói, bạn sẽ sử dụng import foo hoặc from foo import Bar.2解释器会先在当前目录里搜索foo.pyTrong Python 3, quá trình này hơi khác một chút. Python 3 không tìm kiếm trước ở đường dẫn hiện tại, nó sẽ tìm kiếm trực tiếp trong đường dẫn tìm kiếm của Python. Nếu bạn muốn nhập một mô-đun trong gói vào một mô-đun khác trong gói, bạn cần phải cung cấp một cách rõ ràng các đường tương đối của hai mô-đun.
Giả sử bạn có nhiều tập tin trong cùng một thư mục:
Chardet/ Ừm. ±-init.py Ừm.+--constants.py | +--mbcharsetprober.py | +--universaldetector.py
Bây giờ giả sử rằng universaldector.py cần phải nhập toàn bộ constants.py，另外还需要导入mbcharsetprober.py的一个类。你会怎样做?
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | hằng số nhập khẩu | từ các hằng số.import |
| ② | từ mbcharsetprober nhập MultiByteCharSetProber | từ.mbcharsetprober nhập MultiByteCharsetProber |
1, Khi bạn cần nhập toàn bộ mô-đun từ nơi khác trong gói, hãy sử dụng từ mới. import syntax.universaldetector.py) và bạn muốn nhập các tập tin ((constants.pyTrong ví dụ này, hai tập tin này nằm trong cùng một thư mục, do đó sử dụng một dấu chấm duy nhất. Bạn cũng có thể nhập từ thư mục cha ((from... import anothermodule) hoặc từ thư mục con. 2, để nhập một lớp hoặc hàm cụ thể từ các module khác trực tiếp vào namespace của module của bạn, hãy thêm đường tương đối vào đầu module cần nhập và loại bỏ dấu gạch cuối cùng. Trong trường hợp này, mbcharsetprober.py và universaldetector.py nằm trong cùng một thư mục, vì vậy tên đường tương đối là một dấu chấm. Bạn cũng có thể nhập từ thư mục cha ((from... import anothermodule) hoặc từ thư mục con).
Trong Python 2, lập trình viên có một phương pháp next (), để trả về mục tiếp theo trong chuỗi. Trong Python 3, điều này cũng được thực hiện, nhưng bây giờ có một hàm toàn cầu mới next (), nó sử dụng một lập trình viên như là một tham số.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | anIterator.next ((() | next ((aniterator) |
| ② | a_function_that_returns_an_iterator().next() | next ((a_function_that_returns_an_iterator()) |
| ③ | class A: def next ((self): pass |
lớp A:tiếp theo.(tự): pass |
| ④ | lớp A: def next ((self, x, y): pass |
không thay đổi |
| ⑤ | next = 42 đối với an_iterator trong a_sequence_of_iterators: an_iterator.next() |
next = 42 cho một_iterator trong a_sequence_of_iterators: một_iterator._tiếp theo.() |
Ví dụ đơn giản nhất, bạn không còn gọi phương thức next (() của một trình lập trình, bạn đang chuyển tự trình lập trình thành một tham số cho hàm toàn cầu next ((). 2, nếu bạn có một giá trị được trả về là một hàm của trình lặp, hãy gọi hàm này và chuyển kết quả thành một tham số cho hàm next((((((script 2to3 đủ thông minh để thực hiện chuyển đổi này một cách chính xác)). 3, nếu bạn giả định một lớp của riêng bạn và sử dụng nó như một trình lặp, trong Python 3, bạn có thể làm điều đó bằng cách xác định các phương thức đặc biệt.tiếp theo.(Để thực hiện). 4, nếu bạn định nghĩa một lớp chỉ có một next ((), nó sẽ sử dụng một hoặc nhiều tham số, 2to3 sẽ không kích hoạt nó khi thực hiện. 5, một chút phức tạp. Nếu bạn tình cờ có một biến địa phương có tên là next, trong Python 3 nó sẽ được ưu tiên cao hơn so với hàm toàn cầu next ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((tiếp theo.() để lấy phần tử tiếp theo trong chuỗi. Bạn cũng có thể xây dựng lại mã để tên biến địa phương này không phải là next, nhưng 2to3 sẽ không làm điều đó cho bạn.
Trong Python 2, phương pháp filter ((() trả về một danh sách, một danh sách được kiểm tra bởi một hàm trả về giá trị True hoặc False cho mỗi mục trong chuỗi. Trong Python 3, hàm filter ((() trả về một lặp, không còn là một danh sách.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | filter ((a_function, a_sequence) | list ((filter ((a_function, a_sequence)) |
| ② | list ((filter ((a_function, a_sequence)) | không thay đổi |
| ③ | filter ((Không có, a_sequence) | [i cho iin a_sequence nếu i] |
| ④ | cho i trong bộ lọc ((Không có, a_sequence): | không thay đổi |
| ⑤ | [i cho bộ lọc iin ((a_function, a_sequence) ] | không thay đổi |
Trong trường hợp đơn giản nhất, 2to3 sẽ sử dụng một hàm list (()) để gói filter ((), và hàm list (()) sẽ đi qua các tham số của nó và trả về một danh sách. Tuy nhiên, nếu một cuộc gọi filter (()) đã được list (()) gói, 2to3 sẽ không xử lý nữa, vì trong trường hợp đó, giá trị được trả về của filter (()) là một iterator không quan trọng. 3, để xử lý một ngữ pháp đặc biệt như filter ((None,...), 2to3 sẽ chuyển đổi cuộc gọi này từ ngữ pháp tương đương thành phân tích danh sách. 4, vì vòng lặp for sẽ đi qua toàn bộ chuỗi, không cần phải thay đổi thêm. 5, giống như trên, không cần phải thay đổi, vì danh sách phân tích sẽ đi qua toàn bộ chuỗi, và ngay cả khi filter () trở lại một trình lặp, nó vẫn hoạt động bình thường như filter () trước đó trở lại danh sách.
Cũng giống như thay đổi của filter ((), hàm map (() giờ đây trả về một trình lặp. Trong Python 2, nó trả về một danh sách.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | map ((a_function, |
danh sách ((map ((a_function, |
| ② | map ((None, |
danh sách (( |
| ③ | map ((lambda x: x+1,range ((42)) | [x + 1 cho x trong phạm vi ((42)] |
| ④ | cho i trong map ((a_function, a_sequence): | không thay đổi |
| ⑤ | [i for iin map ((a_function,a_sequence) ] | không thay đổi |
1, tương tự như đối với filter ((), trong trường hợp đơn giản nhất, 2to3 sẽ sử dụng một list (() chức năng để gói map (() gọi. 2、 Đối với đặc biệt map ((None,...) ngữ pháp, tương tự như filter ((None,...), 2to3 sẽ chuyển đổi nó thành một cuộc gọi tương đương với sử dụng list ((). 3, nếu tham số đầu tiên của map () là một hàm lambda, 2to3 sẽ chuyển đổi nó thành giải pháp danh sách tương đương. 4, không cần phải thay đổi cho vòng lặp for đi qua toàn bộ chuỗi. 5, một lần nữa, không cần phải sửa đổi ở đây, bởi vì danh sách phân tích sẽ đi qua toàn bộ chuỗi, và nó sẽ hoạt động tốt ngay cả khi giá trị trả về của map ((() là một trình lặp thay vì danh sách.
Trong Python 3, hàm reduce (), đã được loại bỏ khỏi không gian tên toàn cầu và được đặt trong module fucntools.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | giảm (a, b, c) | từ các công cụ hoạt động nhập khẩu giảm giảm (a, b, c) |
Python 2 có một hàm toàn cầu có tên là apply ((), nó sử dụng một hàm f và một danh sách [a, b, c] như là các tham số, và trả về giá trị là f ((a, b, c)). Bạn cũng có thể thực hiện điều tương tự bằng cách gọi trực tiếp hàm này và thêm một dấu ngoặc (*) trước danh sách để chuyển qua nó như một tham số. Trong Python 3, hàm apply (() không còn tồn tại; phải sử dụng cách đánh dấu dấu ngoặc).
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | apply ((a_function, a_list_of_args) | a_function ((*a_list_of_args) |
| ② | apply ((a_function, a_list_of_args, a_dictionary_of_named_args) | a_function ((*a_list_of_args,**a_dictionary_of_named_args) |
| ③ | apply ((a_function, a_list_of_args+ z) | a_function ((*a_list_of_args+ z) |
| ④ | áp dụng ((aModule.a_function, a_list_of_args) | aModule.a_function ((*a_list_of_args) |
Trong dạng đơn giản nhất, bạn có thể gọi hàm bằng cách thêm một dấu sao trước danh sách các tham số (như [a, b, c]). 2, Trong Python 2, hàm apply ((() thực sự có thể mang 3 tham số: một hàm, một danh sách tham số, một từ điển tên tham số ((dictionary of named arguments)). Trong Python 3, bạn có thể thêm một dấu chấm trước danh sách tham số (((), thêm hai dấu sao ((**) trước các tham số đặt tên từ điển để đạt được hiệu quả tương tự. 3, toán tử + được sử dụng ở đây như một chức năng của danh sách kết nối, nó có ưu tiên cao hơn các toán tử, vì vậy không cần phải thêm dấu ngoặc thêm xung quanh a_list_of_args + z. Các kịch bản 4 và 2 đến 3 đủ thông minh để chuyển đổi các cuộc gọi apply phức tạp, bao gồm cả các cuộc gọi nhập vào các hàm trong module.
Trong Python 2, bạn có thể sử dụng chức năng intern để giới hạn chức năng này trên một chuỗi để tối ưu hóa hiệu suất. Trong Python 3, chức năng này đã được chuyển sang mô-đun sys.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | intern ((aString) | sys.intern ((aString) |
Giống như câu lệnh print trở thành một hàm trong Python 3, câu lệnh exec cũng như vậy.exec () hàm sử dụng một chuỗi chứa bất kỳ mã Python nào như một tham số và sau đó thực hiện nó giống như một câu lệnh thực thi hoặc biểu thức.exec () tương tự như eval () nhưng exec () mạnh mẽ hơn và tinh tế hơn.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | exec codeString | exec ((codeString) |
| ② | exec codeString trong không gian tên toàn cầu | exec ((codeString, a_global_namespace) |
| ③ | exec codeString trong không gian tên toàn cầu, không gian tên địa phương | exec ((codeString, a_global_namespace,a_local_namespace) |
1, trong hình thức đơn giản nhất, vì exec ((() bây giờ là một hàm, chứ không phải là một câu lệnh, 2to3 sẽ dùng dấu ngoặc để vạch ra mã dạng chuỗi này. 2, câu lệnh exec trong Python 2 có thể chỉ ra không gian tên, mã sẽ được thực hiện trong không gian riêng gồm các đối tượng toàn cầu. Python 3 cũng có chức năng này; bạn chỉ cần chuyển không gian tên này sang hàm exec () như một tham số thứ hai. 3, thậm chí còn kỳ diệu hơn, câu lệnh exec trong Python 2 cũng có thể chỉ định một không gian tên cục bộ (ví dụ như một biến được tuyên bố trong một hàm). Trong Python 3, hàm exec () cũng có chức năng này.
Giống như lệnh exec trước đây, lệnh execfile trong Python 2 cũng có thể sử dụng chuỗi giống như thực hiện mã Python; khác biệt là exec sử dụng chuỗi, trong khi execfile sử dụng tập tin. Trong Python 3, lệnh execfile đã bị loại bỏ. Nếu bạn thực sự muốn thực hiện mã Python trong một tập tin ((nhưng bạn không muốn nhập nó), bạn có thể thực hiện bằng cách mở tập tin này, đọc nội dung của nó, sau đó gọi compile) toàn cầu chức năng ((Python interpreter bắt buộc biên dịch mã, sau đó gọi một chức năng exec mới)).
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | execfile (( |
exec(compile(open (( |
Trong Python 2, để có được một chuỗi ký tự của bất kỳ đối tượng nào, có một cách để đóng gói đối tượng trong dấu ngoặc ngược (ví dụ:xMột phần của nó là một thuật ngữ đặc biệt. Trong Python 3, khả năng này vẫn tồn tại, nhưng bạn không thể sử dụng dấu ngoặc để có được một chuỗi như vậy. Bạn cần sử dụng hàm toàn cầu repr.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | `x` | repr ((x) |
| ② | ` |
repr (( |
Nhớ rằng, x có thể là bất cứ thứ gì, một lớp, một hàm, một module, một kiểu dữ liệu cơ bản, v.v.; repr (); hàm có thể sử dụng bất kỳ kiểu tham số nào. 2, trong Python 2, các dấu ngoặc ngược có thể được ghép, dẫn đến biểu thức khó hiểu nhưng hiệu quả này. 2to3 đủ thông minh để chuyển đổi các cuộc gọi ghép này thành hàm repr.
Từ Python 2 đến Python 3, ngữ pháp bắt bất thường có thể thay đổi một chút.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | try: import mymodule except ImportError, e pass |
try: import mymodule except ImportError như e: pass |
| ② | try: import mymodule except (RuntimeError, ImportError), e pass |
try: import mymodule except (RuntimeError, ImportError) như e: pass |
| ③ | try: import mymodule except ImportError: pass |
không thay đổi |
| ④ | thử: nhập mymodule trừ: pass |
không thay đổi |
1, so với Python 2 thêm dấu chấm sau kiểu ngoại lệ, Python 3 sử dụng một từ khóa mới, as. 2, từ khóa as cũng có thể được sử dụng trong trường hợp bắt được nhiều loại ngoại lệ cùng một lúc. Nếu bạn bắt gặp một sự khác biệt nhưng không quan tâm đến việc truy cập vào đối tượng khác biệt, Python 2 và Python 3 có cùng một ngữ pháp. 4, tương tự như vậy, nếu bạn sử dụng một phương pháp bảo hiểm (fallback) để bắt tất cả các ngoại lệ, ngữ pháp của Python 2 và Python 3 là giống nhau. Nếu không, chương trình có thể bắt gặp sự khác biệt như Keyboard Interrupt (nếu người dùng nhấn Ctrl-C để ngắt chương trình), làm cho việc debugging trở nên khó khăn hơn.
Trong Python 3, có những thay đổi nhỏ trong ngữ pháp để ném các ngoại lệ tùy chỉnh.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | nâng MyException | không thay đổi |
| ② | nâng MyException, |
tăng MyException (( |
| ③ | nâng MyException, |
raise MyException (( |
| ④ | nâng |
không hỗ trợ |
Trong hình thức đơn giản nhất, ngữ pháp không thay đổi. 2, khi bạn muốn ném một ngoại lệ với thông báo lỗi tùy chỉnh của người dùng, thay đổi là hiển nhiên. Python 2 sử dụng dấu chấm để tách loại ngoại lệ và thông báo lỗi; Python 3 truyền thông báo lỗi như một tham số cho loại ngoại lệ. 3, Python 2 hỗ trợ một ngữ pháp phức tạp hơn để ném một ngoại lệ với sự truy cập theo cách tùy chỉnh của người dùng (stack trace, theo dõi ngăn xếp). Trong Python 2, bạn có thể ném một ngoại lệ không có loại ngoại lệ, chỉ có một thông báo ngoại lệ. Trong Python 3, hình thức này không còn được hỗ trợ. 2to3 sẽ cảnh báo bạn rằng nó không thể tự động sửa ngữ pháp này.
Trong Python 2, trình tạo có một phương pháp throw (); gọi a_generator.throw (); sẽ ném một ngoại lệ khi trình tạo được tạm dừng và trả lại giá trị tiếp theo được lấy từ hàm trình tạo. Trong Python 3, chức năng này vẫn có thể sử dụng, nhưng có một chút khác biệt về ngữ pháp.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | a_generator.throw ((MyException)) | không thay đổi |
| ② | a_generator.throw ((MyException, |
a_generator.throw ((MyException (( |
| ③ | a_generator.throw (( |
không hỗ trợ |
1, trong hình thức đơn giản nhất, trình tạo ném ra các ngoại lệ mà không có thông báo sai lầm tùy chỉnh của người dùng. Trong trường hợp này, không có sự thay đổi về ngữ pháp từ Python 2 đến Python 3. 2, nếu trình tạo phát ra một ngoại lệ với thông báo lỗi tùy chỉnh của người dùng, bạn cần phải truyền chuỗi thông báo lỗi này đến lớp ngoại lệ để thực hiện nó. 3, Python 2 cũng hỗ trợ ném ngoại lệ chỉ với thông báo ngoại lệ. Python 3 không hỗ trợ ngữ pháp này và 2to3 sẽ hiển thị một thông báo cảnh báo cho bạn biết bạn cần sửa mã này một cách thủ công.
Trong Python 2, có hai cách để lấy số trong một phạm vi nhất định: range ((), nó trả về một danh sách, và range ((), nó trả về một trình lặp. Trong Python 3, range (() trả về trình lặp, xrange (() không còn tồn tại nữa.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | xrange ((10) | phạm vi ((10) |
| ② | a_list = range ((10) | a_list = list ((range ((10)) |
| ③ | [i trong phạm vi x)) | [i cho phạm vi in ((10) ] |
| ④ | đối với i trong phạm vi ((10): | không thay đổi |
| ⑤ | Tổng số (Phạm vi) | không thay đổi |
1, trong trường hợp đơn giản nhất, 2to3 sẽ đơn giản chuyển đổi xrange (()) thành range (()). 2, Nếu mã Python 2 của bạn sử dụng range (), 2to3 không biết bạn có cần một danh sách hay không, hoặc nếu một trình lặp cũng chạy. Vì sự thận trọng, 2to3 có thể báo cáo lỗi, sau đó sử dụng list (), buộc giá trị trả lại của range () được chuyển đổi thành loại danh sách. 3, nếu trong phân tích danh sách có hàm xrange ((), không cần phải chuyển đổi giá trị trả về của nó thành một danh sách, vì phân tích danh sách cũng có hiệu quả đối với các trình lặp. 4, tương tự như vậy, vòng lặp for cũng hoạt động trên các trình lặp, vì vậy không thay đổi bất cứ điều gì ở đây. 5, hàm sum () có thể hoạt động trên các trình lặp, vì vậy 2to3 cũng không thay đổi ở đây. Cũng giống như phương pháp trả về giá trị view thay vì danh sách, điều này cũng áp dụng cho min (), max (), sum (), list (), tuple (), set (), sorted (), any (), all ().
Python 2 có hai chức năng toàn cầu được sử dụng để yêu cầu người dùng nhập vào dòng lệnh. Đầu tiên là input (), nó chờ người dùng nhập một biểu thức Python (), và trả về kết quả (). Thứ hai làraw_input (), nó trả về bất cứ điều gì người dùng nhập. Điều này gây nhầm lẫn cho người mới bắt đầu, và điều này được xem là một món thịt nướng của ngôn ngữ Python.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | raw_input() | đầu vào |
| ② | raw_input (( |
input (( |
| ③ | đầu vào | Đánh giá (đưa vào) |
Trong hình thức đơn giản nhất, raw_input ((() được thay thế bằng input ((()). 2, trong Python 2, hàm raw_input (()) có thể chỉ định một dấu hiệu gợi ý như một tham số. Trong Python 3, chức năng này được giữ lại. 3, nếu bạn thực sự muốn yêu cầu người dùng nhập một biểu thức Python, bạn có thể tính toán kết quả bằng cách gọi hàm input và chuyển giá trị trả về đến eval.
Trong Python 2, mã trong hàm có thể truy cập vào các thuộc tính đặc biệt của chính hàm. Trong Python 3, các thuộc tính đặc biệt này đã được đổi tên để phù hợp.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | a_function.func_name | a_function._tên_ |
| ② | a_function.func_doc | a_function._Doc_ |
| ③ | a_function.func_defaults | a_function._mặc định_ |
| ④ | a_function.func_dict | a_function._Định lệnh |
| ⑤ | a_function.func_closure | a_function._đóng cửa |
| ⑥ | a_function.func_globals | a_function._toàn cầu |
| ⑦ | a_function.func_code | a_function._mã_ |
1, thuộc tính __name__ ((func_name gốc) chứa tên của hàm. 2, __doc__ thuộc tính ((funcdoc gốc) chứa các chuỗi tài liệu (docstring) mà bạn xác định trong mã nguồn của hàm 3, __defaults__ thuộc tính ((originalfunc_defaults) là một tập hợp các phần tử lưu trữ các giá trị mặc định của các tham số. 4,__dict__ thuộc tính ((originalfunc_dict) là một namespace hỗ trợ thuộc tính của các hàm tùy chọn. 5, __closure__ thuộc tính ((originalfunc_closure)) là một tập hợp các đối tượng của cell, nó chứa các chức năng liên kết với các biến tự do (free variable). Các thuộc tính __globals__ (trước đây là function_globals) là một tham chiếu đến không gian tên toàn cầu của một module, và các hàm được định nghĩa trong không gian tên này. 7,__code__ thuộc tính ((originalfunc_code) là một đối tượng mã, biểu thị các cơ thể chức năng sau khi biên dịch.
Trong Python 2, đối tượng tập tin có phương pháp xreadlines (), nó trả về một trình lặp, đọc một dòng tập tin một lần. Điều này đặc biệt hữu ích trong vòng lặp for. Thực tế, các phiên bản Python 2 sau đó đã thêm chức năng này cho các đối tượng tập tin.
Trong Python 3, phương pháp xreadlines ((() không còn khả dụng. 2to3 có thể giải quyết các tình huống đơn giản, nhưng một số trường hợp bên cạnh sẽ cần sự can thiệp của con người.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | cho dòng trong a_file.xreadlines(): | cho dòng trong file: |
| ② | cho dòng trong a_file.xreadlines(5): | không thay đổi (bẻ gãy) |
1, nếu bạn đã gọi xreadlines mà không có tham số trước đó, 2to3 sẽ chuyển đổi nó thành đối tượng tập tin chính nó. Trong Python 3, mã sau khi chuyển đổi này có thể thực hiện cùng một công việc trước đó: đọc một dòng tập tin một lần và sau đó thực hiện vòng lặp for.
Nếu trước đây bạn đã sử dụng một tham số (tạm dịch: số dòng đọc mỗi lần) để gọi xreadlines (tạm dịch: số dòng đọc mỗi lần) và 2to3 không thể thực hiện chuyển đổi từ Python 2 sang Python 3 cho bạn, mã của bạn sẽ thất bại theo cách này: AttributeError:
Trong Python 2, bạn có thể định nghĩa một hàm lambda ẩn danh (anonymous lambda function) để thực sự cho phép hàm này nhận được nhiều tham số bằng cách chỉ định số phần tử của một tập hợp thành một tham số. Trên thực tế, trình giải thích của Python 2 giải mã các phần tử này thành các tham số được đặt tên (named arguments), sau đó bạn có thể tham khảo chúng trong hàm lambda (named arguments). Trong Python 3, bạn vẫn có thể truyền một tập hợp thành các tham số của hàm lambda, nhưng trình giải thích Python không giải quyết nó thành các tham số được đặt tên.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | lambda (x,): x+ f ((x) | lambda x1: x1[0]+f(x1[0]) |
| ② | lambda (x, y): x+f(y) | lambda x_y: x_y[0]+f(x_y[1]) |
| ③ | lambda (x,(y,z)): x+ y+ z | lambda x_y_z: x_y_z[0]+x_y_z[1][0]+ x_y_z[1][1] |
| ④ | lambda x, y, z: x+y + z | không thay đổi |
1, nếu bạn đã định nghĩa một hàm lambda, nó sử dụng một phần tử có chứa một phần tử như một tham số, trong Python 3, nó sẽ được chuyển đổi thành một hàm lambda có chứa một tham chiếu đến x1[0]; x1 là một kịch bản 2to3 tự động tạo ra dựa trên các tham số tên trong phần tử gốc. 2, sử dụng một tập hợp gồm hai phần tử ((x, y) như là một tham số của hàm lambda được chuyển thành x_y, nó có hai tham số vị trí, đó là x_y[0] và x_y[1]; Các kịch bản 3, 2to3 thậm chí có thể xử lý các hàm lambda với các phần tử sử dụng các tham số đặt tên mảng. Các mã kết quả được tạo ra hơi khó đọc, nhưng nó có tác dụng tương tự trong Python 3 như mã gốc trong Python 2. 4, bạn có thể định nghĩa một hàm lambda sử dụng nhiều tham số. Nếu không có dấu ngoặc quanh tham số, Python 2 sẽ coi nó như một hàm lambda chứa nhiều tham số; trong thân hàm lambda này, bạn tham chiếu các tham số này bằng tên, giống như các hàm loại khác.
Trong Python 2, các phương thức lớp có thể truy cập vào các đối tượng lớp xác định của họ, cũng như truy cập vào các đối tượng phương pháp chính nó; im_self là đối tượng mẫu của lớp; im_func là đối tượng hàm, im_class là lớp chính nó. Trong Python 3, các thuộc tính này được đổi tên để tuân theo các quy ước đặt tên cho các thuộc tính khác.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | aClassInstance.aClassMethod.im_func | ClassInstance.ClassMethod._func_ |
| ② | aClassInstance.aClassMethod.im_self | ClassInstance.ClassMethod._bản thân mình |
| ③ | aClassInstance.aClassMethod.im_class | ClassInstance.ClassMethod._bản thân mình._class_ |
Trong Python 2, bạn có thể tạo các lớp của riêng bạn và làm cho chúng có thể được sử dụng trong bối cảnh boolean. Ví dụ, bạn có thể thể hiện thực hóa lớp và sử dụng đối tượng của trường hợp này trong một câu if. Để thực hiện mục đích này, bạn xác định một_ đặc biệt.không bằng 0() phương thức, giá trị trả về của nó là True hoặc False, phương pháp này được gọi khi đối tượng trong trường hợp trong ngữ cảnh trên Boolean. Trong Python 3, bạn vẫn có thể thực hiện cùng một chức năng, nhưng tên của phương thức đặc biệt này đã trở thànhbool_()。
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | lớp A:không bằng 0(self): vượt qua |
lớp A:bool_(self): vượt qua |
| ② | lớp A:không bằng 0(bản thân, x, y): vượt qua |
không thay đổi |
Một, khi dùng một class object trong context của boolean, Python 3 sẽ gọi_bool_(), chứ không phải làkhông bằng 0() ◄ Nhưng nếu bạn có một định nghĩa sử dụng hai tham số.không bằng 0Phương pháp () 2to3 sẽ giả định rằng phương pháp mà bạn định nghĩa có mục đích khác và do đó sẽ không thay đổi mã.
Trong Python 2 và Python 3, có một sự thay đổi nhỏ về ngữ pháp xác định số octal.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | x = 0755 | x = 0o755 |
Các định lượng sys.maxint không còn chính xác nữa vì kiểu dài và kiểu nguyên được tích hợp với nhau. Nhưng vì giá trị này vẫn hữu ích cho khả năng phát hiện nền tảng cụ thể, nó được Python 3 giữ lại và đổi tên thành sys.maxsize.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | từ sys importmaxint | từ sys importmaxsize |
| ② | a_function ((sys.maxint) | a_function ((sys.maxsize) |
1,maxint trở thành maxsize. 2, tất cả sys.maxint trở thành sys.maxsize.
Trong Python 2, bạn có thể sử dụng hàm toàn cầu callable để kiểm tra một đối tượng có thể gọi được hay không. Trong Python 3, hàm toàn cầu này đã bị hủy bỏ. Để kiểm tra một đối tượng có thể gọi được hay không, bạn có thể kiểm tra một phương pháp đặc biệt.gọi_Có một số người cho rằng:
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | có thể gọi (bất cứ điều gì) | Không có gì cả, |
Trong Python 2, hàm toàn cầu zip ((() có thể sử dụng bất kỳ chuỗi nào như một tham số, nó trả về một danh sách được tạo thành từ các phần tử. Phần tử đầu tiên chứa phần tử đầu tiên của mỗi chuỗi; phần tử thứ hai chứa phần tử thứ hai của mỗi chuỗi; và sau đó đẩy xuống. Trong Python 3, zip ((() trả về một trình lặp, chứ không phải danh sách.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | zip ((a, b, c) | danh sách ((zip ((a, b, c)) |
| ② | d.join ((zip ((a, b, c)) | không thay đổi |
Trong hình thức đơn giản nhất, bạn có thể khôi phục lại chức năng zip trước đó bằng cách gọi giá trị trả về của list() hàm gói zip ((), chức năng list() sẽ đi qua các trình lặp mà zip() chức năng trả về và trả lại danh sách các biểu hiện kết quả. Các trình lập trình zip () trả về sẽ hoạt động bình thường trong môi trường ngữ cảnh mà đã đi qua tất cả các phần tử trong chuỗi (ví dụ như gọi phương thức join) ở đây. Các kịch bản 2to3 sẽ phát hiện những tình huống này mà không thay đổi mã của bạn.
Trong Python 2, StandardError là tất cả các loại cơ sở bất thường tích hợp khác ngoài StopIteration, GeneratorExit, KeyboardInterrupt, và SystemExit. Trong Python 3, StandardError đã bị loại bỏ; thay thế bằng Exception.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | x =StandardError (() | x = ngoại lệ |
| ② | x =StandardError ((a, b, c) | x = ngoại lệ ((a, b, c) |
Trong mô-đun types, các biến thể khác nhau giúp bạn xác định loại của một đối tượng. Trong Python 2, nó chứa các biến thể đại diện cho tất cả các kiểu dữ liệu cơ bản, chẳng hạn như dict và int. Trong Python 3, các biến thể này đã bị xóa bỏ.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| types.UnicodeType | str | |
| types.StringType | byte | |
| types.DictType | dict | |
| types.IntType | int | |
| types.LongType | int | |
| types.ListType | danh sách | |
| types.NoneType | loại ((Không có) | |
| types.BooleanType | bool | |
| types.BufferType | memoryview | |
| types.ClassType | loại | |
| types.ComplexType | phức tạp | |
| types.EllipsisType | kiểu (Ellips) | |
| types.FloatType | trôi | |
| types.ObjectType | đối tượng | |
| types.NotImplementedType | loại ((Không được thực hiện) | |
| types.SliceType | slice | |
| types.TupleType | tuple | |
| types.TypeType | loại | |
| types.XRangeType | phạm vi |
types.StringType được lập dạng bằng byte, chứ không phải str, bởi vì string string trong Python 2 thực sự chỉ là một chuỗi byte được mã hóa bằng một số ký tự.
isinstance () kiểm tra xem một đối tượng có phải là một trường hợp của một loại (class) hoặc kiểu (type) cụ thể. Trong Python 2, bạn có thể truyền một phần tử được tạo thành từ kiểu (types) cho một sự kiện (isinstance), và nếu đối tượng là bất kỳ loại nào trong nhóm, hàm trả về True. Trong Python 3, bạn vẫn có thể làm như vậy, nhưng không khuyến khích sử dụng một loại như một tham số để truyền hai lần.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| isinstance ((x, ((int,float,int)) | isinstance ((x, ((int, float)) |
Python 2 có hai loại chuỗi: chuỗi mã hóa Unicode và chuỗi mã hóa phi Unicode. Nhưng thực sự có một loại khác, basestring. Nó là một loại dữ liệu trừu tượng, là một siêu lớp của kiểu str và unicode. Nó không thể được gọi trực tiếp hoặc thể hiện, nhưng bạn có thể sử dụng nó như một tham số của một instance để kiểm tra một đối tượng là một chuỗi Unicode hay một chuỗi không Unicode.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| isinstance ((x, basestring) | isinstance ((x, str) |
Python 2.3 giới thiệu mô-đun itertools, nó xác định các biến thể (variant) của các hàm toàn cầu zip, map và filter, với kiểu trả về là lặp, chứ không phải danh sách. Trong Python 3, các biến thể trong các itertools đã bị loại bỏ vì kiểu trả về của các hàm toàn cầu này vốn là lặp.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | itertools.izip ((a, b) | zip ((a, b) |
| ② | itertools.imap ((a, b) | bản đồ ((a, b) |
| ③ | itertools.ifilter ((a, b) | filter ((a, b) |
| ④ | từ itertools nhập imap, izip, foo | từ itertools nhập foo |
1, sử dụng hàm zip ((() toàn cầu, thay vì itertools.izip ((() ). 2、 sử dụng map (() thay vì itertools.imap (() ー 3,itertools.ifilter ((() trở thành filter ((() ▽ Các mô-đun itertools vẫn tồn tại trong Python 3, nó chỉ không còn chứa các hàm đã được chuyển sang không gian tên toàn cầu. Các kịch bản 2to3 có thể đủ thông minh để loại bỏ các câu nhập khẩu không còn hữu ích, trong khi vẫn duy trì tính toàn vẹn của các câu nhập khẩu khác.
Khi xử lý ngoại lệ, có ba biến trong module sys mà bạn có thể truy cập: sys.exc_type, sys.exc_value, sys.exc_traceback. (Thực ra, chúng đã có trong thời kỳ Python 1).
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| sys.exc_type | sys.exc_info()[0] | |
| sys.exc_value | sys.exc_info (()) [1] | |
| sys.exc_traceback | sys.exc_info() [2] |
Trong Python 2, nếu bạn cần viết một phân tích danh sách đi qua các phân tử, bạn không cần thêm dấu ngoặc xung quanh các giá trị phân tử. Trong Python 3, các dấu ngoặc là bắt buộc.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| [i cho trong 1,2] | [i cho iin(1,2)] |
Python 2 có một hàm gọi là os.getcwd (), nó trả về thư mục làm việc hiện tại như một ký tự (không mã hóa Unicode). Vì hệ thống tập tin hiện đại có thể xử lý tên thư mục có thể mã hóa bằng nhiều ký tự, Python 2.3 đã giới thiệu hàm os.getcwdu (), hàm os.getcwdu (), chức năng trả về một ký tự mã hóa Unicode cho thư mục làm việc hiện tại. Trong Python 3, bạn chỉ cần os.getcwd (), vì chỉ có một ký tự (thuộc loại Unicode).
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| os.getcwdu ((() | os.getcwd() |
Trong Python 2, bạn có thể tạo ra một class meta bằng cách xác định tham số metaclass trong tuyên bố của class, hoặc xác định một thuộc tính __metaclass__ ở cấp lớp đặc biệt. Trong Python 3, thuộc tính __metaclass__ đã bị hủy bỏ.
| Chú ý | Python 2 | Python 3 |
|---|---|---|
| ① | class C ((metaclass=PapayaMeta): pass |
không thay đổi |
| ② | class Whip: _metaclass_= PapayaMeta |
class Whip ((metaclass=PapayaMeta): pass |
| ③ | lớp C ((Whipper, Beater):metaclass_= PapayaMeta | lớp C ((Whipper,Beater,metaclass=PapayaMeta): vượt qua |
1, tuyên bố tham số metaclass khi tuyên bố lớp, điều này có hiệu quả trong Python 2 và Python 3, chúng giống nhau. 2, trong định nghĩa của lớp, tuyên bố thuộc tính __metaclass__ có hiệu lực trong Python 2, nhưng không còn hiệu lực trong Python 3. 3, 2to3 có thể xây dựng một tuyên bố lớp hiệu quả, ngay cả khi lớp được thừa hưởng từ nhiều lớp cha.
Các sửa chữa sau đây không thực sự là sửa chữa thực sự; nghĩa là, chúng chỉ là những thứ về phong cách của mã, không liên quan đến bản chất của mã. Nhưng các nhà phát triển Python có một lợi ích lớn trong việc làm cho phong cách mã phù hợp nhất có thể. Để làm điều này, có một hướng dẫn chính thức chuyên về mô tả phong cách mã Python.
Trong Python 2, cách duy nhất để định nghĩa một literal set là gọi set a_sequence. Trong Python 3, điều này vẫn có hiệu quả, nhưng sử dụng ký hiệu chữ cái mới: dấu ngoặc lớn là một cách rõ ràng hơn. Cách này cũng có hiệu quả ngoại trừ các empty set, vì từ điển cũng sử dụng dấu ngoặc lớn, vì vậy {} biểu thị một empty dictionary, chứ không phải là một empty set.
Các kịch bản 2to3 sẽ không sửa set (() literal giá trị mặc định. Để kích hoạt chức năng này, khi gọi 2to3 trên dòng lệnh, hãy chỉ định -f set_literal.
| Chú ý | Trước đây | Sau đó |
|---|---|---|
| tập hợp (([1,2,3]) | {1,2,3} | |
| tập hợp (((1,2,3)) | {1,2,3} | |
| set (([i for iin a_sequence]) | {i for iin a_sequence} |
Các đối tượng Python được thực hiện bằng C có thể xuất ra một giao diện bộ đệm (buffer interface) để cho phép các mã Python khác đọc và viết trực tiếp một phần bộ nhớ. Điều này nghe có vẻ mạnh mẽ, nhưng nó cũng khủng khiếp như vậy. Trong Python 3, bộ đệm được đổi tên thành memoryview.
Các kịch bản 2to3 sẽ không sửa chữa chức năng buffer. Để bật chức năng này, hãy chỉ định -f buffer trong lệnh gọi 2to3.
| Chú ý | Trước đây | Sau đó |
|---|---|---|
| x = bộ đệm (y) | x = memoryview ((y)) |
Mặc dù Python có những yêu cầu rất nghiêm ngặt về không gian dùng để thu hẹp và ra ngoài (indenting and outdenting), nhưng Python vẫn rất tự do sử dụng không gian trong các khía cạnh khác. Trong danh sách, phần tử, tập hợp và từ điển, không gian có thể xuất hiện trước hoặc sau dấu phẩy, điều này sẽ không có ảnh hưởng xấu. Tuy nhiên, hướng dẫn phong cách mã Python chỉ ra rằng không thể có không gian trước dấu phẩy và dấu phẩy nên chứa một không gian.
Các kịch bản 2to3 sẽ không sửa các khoảng trống xung quanh dấu ngoặc. Để kích hoạt chức năng này, hãy chỉ định -f wscomma trong lệnh gọi 2to3.
| Chú ý | Trước đây | Sau đó |
|---|---|---|
| a, b | a, b | |
| {a:b} | {a: b} |
Trong cộng đồng Python, nhiều thông lệ đã được xây dựng. Có một số ví dụ như while 1: loop, có nguồn gốc từ Python 1. (Python không có kiểu boolean có ý nghĩa thực sự cho đến khi Python 2.3, vì vậy các nhà phát triển đã sử dụng các thay thế 1 và 0 trước đó). Các lập trình viên Python đương đại nên luyện não của họ để sử dụng các phiên bản hiện đại của các thông lệ này.
Các kịch bản 2to3 sẽ không sửa chữa các thông lệ này theo mặc định. Để bật tính năng này, hãy chỉ định -f idioms trong lệnh gọi 2to3.
| Chú ý | Trước đây | Sau đó |
|---|---|---|
| trong khi 1: do_stuff() |
trong khi True: do_stuff() |
|
| loại ((x) == T | là trường hợp ((x, T) | |
| loại ((x) là T | là trường hợp ((x, T) | |
| a_list = list ((a_sequence) | a_list = sắp xếp (a_sequence) | |
| a_list.sort() | do_stuff (một danh sách) | |
| do_stuff (một danh sách) |
Được chuyển từCSDN blog
Về cách chuyển mã Python 2.x sang mã Python 3.x. Cách chuyển mã Python 2.x sang mã Python 3.x
Điều này không cần phải nói nhiều nếu chỉ liên quan đến một số ít các hàm, chẳng hạn như in và v.v.
Bạn có thể thay đổi mã của mình, bạn cũng có thể.
Các phiên bản Python 2.x, như Python 2.7.2 mà tôi đã cài đặt, đã mang theo một số công cụ hữu ích sau khi tải xuống và cài đặt Windows.
其中一个叫做2to3.pyTrong khi đó, bạn có thể sử dụng một phần mềm khác để thực hiện, chuyển đổi mã Python 2.x sang mã Python 3.x.
Nó được đặt tại: root directory of Python installed \Python27\Tools\Scripts\2to3.py
【如何利用2to3.py, thực hiện chuyển đổi mã Python 2.x sang mã Python 3.x Ví dụ, tôi có một bản kịch bản Python 2.x:
D:\tmp\tmp_dev_root\python\python2_to_python3\34563264_data_from_site.py
Bây giờ, bạn muốn chuyển đổi nó thành mã Python 3.x.
Bạn có thể mở cmd của windows, định vị đến một kịch bản để chuyển đổi và chạy
D:\tmp\WordPress\DevRoot\Python27\Tools\Scripts\2to3.py -w 34563264_data_from_site.py
Sau khi chuyển đổi thành công, kết quả thực hiện tương ứng là:
D:\tmp\tmp_dev_root\python\python2_to_python3>D:\tmp\WordPress\DevRoot\Python27\Tools\Scripts\2to3.py -w 34563264_data_from_site.py
RefactoringTool: Skipping implicit fixer: buffer
RefactoringTool: Skipping implicit fixer: idioms
RefactoringTool: Skipping implicit fixer: set_literal
RefactoringTool: Skipping implicit fixer: ws_comma
RefactoringTool: Refactored 34563264_data_from_site.py
--- 34563264_data_from_site.py (original)
+++ 34563264_data_from_site.py (refactored)
@@ -18,7 +18,7 @@
import time;
import codecs;
import logging;
-import urllib;
+import urllib.request, urllib.parse, urllib.error;
from datetime import datetime,timedelta;
from optparse import OptionParser;
from string import Template,replace;
@@ -90,7 +90,7 @@
foundPhone = eachItemSoup.find(attrs={"class":"phone"});
logging.debug("foundPhone=%s", foundPhone);
if(foundPhone):
- foundPhoneUni = unicode(foundPhone);
+ foundPhoneUni = str(foundPhone);
logging.debug("foundPhoneUni=%s", foundPhoneUni);
# case 1:
#<p class="phone"><strong>phone:</strong> 800.206.7886<br />
@@ -122,7 +122,7 @@
foundWeb = eachItemSoup.find(attrs={"class":"web"});
logging.debug("foundWeb=%s", foundWeb);
if(foundWeb):
- foundWebUni = unicode(foundWeb);
+ foundWebUni = str(foundWeb);
logging.debug("foundWebUni=%s", foundWebUni);
# <p class="web"><strong>e-mail:</strong> <a href="#">sales@cinesysinc.com</a><br />
@@ -151,7 +151,7 @@
foundAddr = eachItemSoup.find(attrs={"class":"addr"});
logging.debug("foundAddr=%s", foundAddr);
if(foundAddr):
- foundAddrUni = unicode(foundAddr);
+ foundAddrUni = str(foundAddr);
# <p class="addr">
# <strong>address:</strong> 740 SW 21st Ave, Suite #310<br />
RefactoringTool: Files that were modified:
RefactoringTool: 34563264_data_from_site.py
Tại thời điểm này, bạn có thể nhìn thấy 34563264_data_from_site.py đã trở thành phiên bản Python 3.x
FangBeiBotvs sử dụng Python 2?
Những nhà phát minh định lượng - những giấc mơ nhỏMáy chủ trả lời của BotVS sử dụng phiên bản Python 2.7, hỗ trợ cả Python 2 và Python 3 cho nền tảng BotVS.