거의 모든 파이썬 2 프로그램은 파이썬 3 환경에서 정상적으로 실행되기 위해 약간의 변경이 필요합니다. 이 변환 과정을 간소화하기 위해, 파이썬 3는 2to3라는 유틸리티 스크립트를 가지고 있습니다. 이 스크립트는 파이썬 2 프로그램의 소스 파일을 입력으로 가져다가 자동으로 파이썬 3 형식으로 변환합니다. 사례 연구: chardet을 파이썬 3으로 포팅하는 경우, 이 스크립트를 실행하는 방법을 설명하고 자동으로 복구할 수 없는 상황을 보여줍니다. 이 부록은 자동으로 복구할 수 있는 내용을 설명합니다.
파이썬 2에서, 프린트 (print) 는 문장이다. 당신이 무엇을 출력하고 싶은지 프린트 키워드 뒤에 두면 된다. 파이썬 3에서, 프린트 (print) 는 함수이다. 다른 함수와 마찬가지로, 프린트 (print) 는 당신이 무엇을 출력하고 싶은지 함수로 전달해야 한다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 인쇄 | 인쇄 (() |
| ② | 인쇄 1 | 인쇄 ((1) |
| ③ | 1,2 인쇄 | 인쇄 (1,2) |
| ④ | 인쇄 1,2, | print ((1,2,end= |
| ⑤ | 프린트 >>sys.stderr,1,2,3 | print ((1,2,3, 파일=sys.stderr) |
1, 빈줄을 출력하기 위해서는 변수가 없는 print ((() 를 호출해야 한다.
2, 개별 값을 출력하려면 이 값을 print () 의 한 함수로 사용할 수 있다.
3, 출력하기 위해 하나의 공간으로 분리된 두 값을 사용해서 두 개의 변수인 print ((() 를 호출할 수 있다.
이 예제에는 몇 가지 트릭이 있습니다. 파이썬 2에서는, 만약 당신이 프린트 문장의 끝으로 코마 (,) 를 사용한다면, 그것은 결과물을 빈 공간으로 분리하고, 그 다음 후속된 빈 공간 (trailing space) 을 출력하면서 카રેજ을 반환하지 않습니다. 파이썬 3에서는, end=
파이썬 2에는 두 가지 문자열 유형이 있습니다.유니코드 문자열그리고비 유니코드 문자열◎ 파이썬 3에는 하나의 타입이 있습니다:유니코드 문자열。
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | ||
| ② | ur |
파이썬 2의 유니코드 문자열은 파이썬 3의 일반 문자열이기 때문에 파이썬 3의 문자열은 항상 유니코드 형식으로 되어 있습니다. 유니코드 원시 문자열 ((raw string) ((이 문자열을 사용하면 파이썬은 자동으로 역역사 (反斜線) 를 만들지 않습니다. ") 는 또한 일반 문자열로 대체되었습니다. 왜냐하면 파이썬 3에서는 모든 원시 문자열이 유니코드로 암호화되어 있기 때문입니다.
파이썬 2에는 객체를 문자열로 강제 변환할 수 있는 두 가지 범용 함수가 있습니다. 유니코드 (unicode) 는 객체를 유니코드 문자열로 변환하고 str (str) 는 객체를 유니코드 아닌 문자열로 변환합니다. 파이썬 3에는 하나의 문자열 유형, 유니코드 문자열이 있습니다. 따라서 str (str) 함수가 모든 기능을 수행합니다.유니코드 (() 함수는 파이썬 3에서 더 이상 존재하지 않습니다.)
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 유니코드 (무엇이든) | str ((아무것도) |
파이썬 2에는 무상점으로 준비된 int와 long 타입이 있다. 이 타입의 최대값은 sys.maxint을 초과할 수 없으며, 이 최대값은 플랫폼에 관계된다. 이 타입은 숫자 끝에 L를 붙여서 긴 정수를 정의할 수 있으며, 분명히, 이 타입은 이 타입이 나타내는 숫자 범위를 초과한다. 파이썬 3에서는 단 하나의 정수 타입인 int가 있으며, 대부분의 경우 파이썬 2의 정수와 비슷하다. 두 종류의 정수가 존재하지 않기 때문에, 그들을 구별하기 위해 특별한 문법을 사용할 필요가 없다.
더 읽어보기:PEP 237: 통일된 전체형과 전체형.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | x = 1000000000000L | x = 1000000000000 |
| ② | x = 0xFFFFFFFFFFFF | x = 0xFFFFFFFFFF |
| ③ | 길게 (x) | int(x) |
| ④ | type ((x) 는 길다 | 타입 (x) 는 int |
| ⑤ | isinstance ((x,long) | isinstance ((x,int) |
파이썬 2의 십진형 정수는 파이썬 3의 십진형 정수로 대체되었다. 파이썬 2의 16진방정식 정수는 파이썬 3의 16진방정식 정수로 대체되었다. 파이썬 3에서는, 전체형이 더 이상 존재하지 않기 때문에,자연에서 원래의 롱 (long) 함수도 없습니다. 변수를 전체형으로 강제로 변환하려면 int (int)) 함수를 사용할 수 있습니다.ᅳ 변수가 전체형인지 확인하고, 데이터 타입을 얻으며, int 타입 ((long가 아닌) 과 비교한다. 당신은 또한 이인스턴스 (() 함수를 사용하여 데이터 타입을 검사할 수 있습니다. 다시 한 번 강조하자면, 롱이 아닌 int를 사용하여 정수 타입을 검사하십시오.
파이썬 2는 <>를!=의 동의어로 지원한다. 파이썬 3는 오직!=만을 지원하고, 더 이상 <>를 지원하지 않는다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 만약 x <> y: | 만약 x!= y: |
| ② | 만약 x <> y <> z: | 만약 x!= y!= z: |
1, 간단하게 비교하십시오. 2, 상대적으로 복잡한 세 개의 값 사이의 비교.
파이썬 2에서는 사전 객체의 has_key ((() 메소드가 사전에 특정 키 ((key)) 가 있는지 테스트하는 데 사용됩니다. 파이썬 3에서는 더 이상 이 메소드를 지원하지 않습니다.안쪽연산자.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | a_dictionary.has_key (( |
|
| ② | a_dictionary.has_key (x) 또는 a_dictionary.has_key (y) | a_dictionary에서 x 또는 a_dictionary에서 y |
| ③ | a_dictionary.has_key ((x 또는 y) | (x 또는 y) a_dictionary에서 |
| ④ | a_dictionary.has_key ((x + y) | (x + y) a_dictionary에서 |
| ⑤ | x + a_dictionary.has_key ((y) | x + (a_dictionary에서 y) |
가장 간단한 형태는 1입니다. 2, or의 우선 순위가 in보다 낮기 때문에, 여기에 괄호를 추가할 필요가 없습니다. 다른 한편으로, 같은 이유 때문에, in보다 낮은 or의 우선순위가 필요하기 때문에, 여기에括号을 추가해야 한다. 참고: 여기의 코드는 이전 줄과 완전히 다릅니다. 파이썬은 먼저 x 또는 y를 해석하여 x (만약 x가 boolean 문맥의 값이 사실이라면) 또는 y를 얻습니다. 그리고 파이썬은 이 결과가 a_dictionary의 키인지 아닌지를 검사합니다. 4, 연산자 in는 연산자 +보다 낮은 우선순위를 가지고 있기 때문에 코드에서 이러한 형태는 기술적으로括号이 필요하지 않지만 2to3는 추가됩니다. 5, 이 형태는 반드시括号이 필요하기 때문에 in의 우선 순위가 +ᆞ보다 낮습니다.
파이썬 2에서는 많은 사전 방법의 반환 값이 목록이다. 그중 가장 많이 사용되는 방법은 키, 아이템, 그리고 값이다. 파이썬 3에서는 모든 방법의 반환 값이 동적 시각으로 변경된다. 어떤 문맥 환경에서 이러한 변화는 아무런 영향을 미치지 않는다. 만약 이러한 방법의 반환 값이 다른 함수에게 즉시 전달되고 그 함수가 일련 전체를 가로질러 이동한다면, 위의 방법의 반환 값은 목록 또는 시각으로 변경되지 않고 아무런 차이가 발생하지 않는다. 다른 경우에, 파이썬 3의 상관관계이다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | a_dictionary.keys() | 목록 (사전.키) |
| ② | 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()) | 변경되지 않습니다. |
1, list () 함수는 keys () 의 반환 값을 정형 목록으로 변환합니다. 보안상의 이유로, 2to3는 오류를 나타낼 수 있습니다. 이러한 코드는 유효하지만 시각을 사용하는 데에는 다소 효율적이지 않습니다. 변환 후 코드를 확인하여 목록이 반드시 필요한지 확인해야하며, 아마도 시각도 같은 작업을 수행 할 수 있습니다. 2、 이것은 다른 시각의 (물질에 관한) 방법의) 리스트로 변환하는 방법이다. 2to3 대 values의 방법의 값의 변환도 마찬가지이다. 3, 파이썬 3에서는 iterkeys (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( 4, 2to3는 리스트 파서에서 사용된 iterkeys (,) 방법을 인식하고 그것을 Python 3의 keys (,) 로 변환할 수 있다. 5, 2to3 또한 keys (() 방법의 반환값을 식별할 수 있으며, 그 값은 즉시 전체 행렬을 탐색하는 다른 함수로 전달되기 때문에, keys (() 의 반환값을 목록으로 변환할 필요가 없습니다. 반대로, min (()) 함수는 보기 전체를 탐색합니다. 이 과정은 min ((), max ((), sum ((), tuple ((), setlist ((), sorted ((), any (() 및 all (()) 에 대해서도 동일하게 작동합니다.
파이썬 2에서 파이썬 3에 이르기까지 표준 라이브러리의 일부 모듈은 명칭이 변경되었다. 또한 서로 연관된 모듈들이 더 논리적으로 연관성을 더하기 위해 조합되거나 재구성되었다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | httplib를 가져오기 | http.client를 가져오기 |
| ② | 가져오기 쿠키 | http.cookies를 가져오기 |
| ③ | cookielib를 가져오기 | http.cookiejar를 가져오기 |
| ④ | BaseHTTPServer 를 가져오기 SimpleHTTPServer 를 가져오기 CGIHttpServer |
http.server를 가져오기 |
http.client 모듈은 HTTP 리소스를 요청하고 HTTP 응답을 분석하는 데 사용할 수 있는 하위 리버리를 구현합니다. http.cookies 모듈은 Set-Cookie를 통해 전송되는 쿠키를 얻기 위해 Python형 인터페이스를 제공합니다. 일반적인 브라우저에서는 쿠키를 파일 형태로 디스크에 저장하고, http.cookiejar 모듈은 이러한 파일을 조작할 수 있습니다. http.server 모듈은 기본적인 HTTP 서버를 구현합니다
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | urllib를 가져오 | urllib.request를 가져오기 |
| ② | urllib2를 가져오세요 | urllib.request를 가져오기 |
| ③ | URL를 가져오기 | urllib.parse를 가져오세요 |
| ④ | 로봇파서 가져오기 | urllib.robotparser를 가져오기 |
| ⑤ | urllib에서 가져오기 FancyURLopener urllib에서 가져오기 urlencode |
urllib.request에서 가져오기 FancyURLopener urllib.parse에서 가져오는 urlencode |
| ⑥ | urllib2에서 가져오기 요청 urllib2에서 가져오기 HTTPError |
urllib.request에서 가져오기 request urllib.error에서 가져오기 HTTPError |
이전에는, 파이썬 2의 urllib 모듈에는 다양한 함수들이 있었다. 데이터 획득을 위해 사용된 urlopen (http://www.urllib.org/) 는 물론, URL을 구성 요소인 splittype (http://www.splittype.org/), splithost (http://www.splithost (http://www.splithost)), splituser (http://www.splituser (http://www.splitter.org/) 등으로 분할하는 데도 유용했다. 새로운 urllib 패키지에서는 이러한 함수들이 더 논리적으로 조직되어 있다. 2to3는 새로운 명칭 계획에 맞게 이러한 함수들의 호출을 수정할 것이다. 파이썬 3에서는 이전 urllib2 모듈이 urllib 패키지로 통합되었다. 동시에 urllib2에서는 다양한 좋아하는 것들이 파이썬 3의 urllib 모듈에 필수적으로 나타날 것입니다. build_opener (), Request object (), HTTPBasicAuthHandler (), and friends (). 파이썬 3의 urllib.parse 모듈은 원래 파이썬 2의 urlparse 모듈의 모든 분석 함수를 포함합니다. urllib.robotparse 모듈은 robots.txt 파일을 분석합니다. HTTP 리디렉트를 처리하고 다른 상태 코드를 처리하는 FancyURLopener 클래스는 파이썬 3의 urllib.request 모듈에서 여전히 유효합니다. urllencode () 함수는 urllib.parse로 이전되었습니다. Request 객체는 urllib.request에서 여전히 유효하지만 HTTPError와 같은 상수는 urllib.error로 이동되었습니다. 제가 2to3가 여러분의 함수 호출을 다시 쓸 것이라고 언급했나요? 예를 들어, 만약 여러분이 Python 2 코드에서 urllib 모듈을 가져와서 urllib.urlopen (,) 함수를 호출하면 2to3는 동시에 import 문장과 함수 호출을 수정합니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | urllib를 가져오기 위해 urllib.urlopen을 인쇄합니다.http://diveintopython3.org/’) 읽는다. | urllib.request, urllib.parse, urllib.error를 가져오세요 print ((urllib.request.urlopen))http://diveintopython3.org/’) 읽습니다. |
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 수입 dbm | dbm.ndbm를 가져오세요 |
| ② | gdbm를 가져오기 | 수입dbm.gnu |
| ③ | dbhash를 가져오기 | dbm.bsd를 가져오기 |
| ④ | Dumbdbm를 가져오세요 | dbm.dumb를 가져오세요 |
| ⑤ | 임파르트 어떤bm 임파르트 어떤db |
수입 dbm |
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | xmlrpclib을 가져오기 | xmlrpc.client를 가져오기 |
| ② | DocXMLRPCServer를 가져오기 | xmlrpc.server를 가져오기 |
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | try: import cStringIO as StringIO except ImportError: import StringIO 이 아닌 cStringIO를 가져오기 |
수입 |
| ② | try: import cPickle as pickle except ImportError: import pickle import pickle import pickle import pickle import pickle import pickle import pickle |
수입 피클 |
| ③ | 가져와빌트인 | 수입 건축물 |
| ④ | copy_reg를 가져오기 | 수입 복사기 |
| ⑤ | 수입 대기열 | 수입 대기열 |
| ⑥ | 소켓 서버를 가져오기 | 소켓 서버를 가져오기 |
| ⑦ | ConfigParser를 가져오기 | 컨피그파서 수입 |
| ⑧ | 수입 repr | 엠포트 reprlib |
| ⑨ | 수입 명령어 | 수입 하위 공정 |
1, 파이썬 2에서는 보통 이렇게 합니다. 먼저 cStringIO를 StringIO의 대안으로 가져오려고 시도하고, 실패하면 StringIO를 다시 가져오세요. 파이썬 3에서는 그렇게 하지 마세요; io 모듈이 이 일을 처리해줍니다. 그것은 사용 가능한 가장 빠른 구현 방법을 찾아내서 자동으로 사용하게 됩니다. 2, 파이썬 2에서는 가장 빠른 피클 구현을 가져오는 것도 위와 비슷한 유용한 방법이다. 파이썬 3에서는 피클 모듈이 자동으로 처리되므로 더 이상 그렇게 하지 마십시오. 3, buildins 모듈은 Python 언어 전체에서 사용되는 범용 함수, 클래스 및 상수를 포함합니다. buildins 모듈의 어떤 함수를 재정의하는 것은 모든 곳에서 이 범용 함수를 재정의하는 것을 의미합니다. 이것은 강력하지만 동시에 무서운 것 같습니다. 4,copyreg 모듈은 C 언어로 정의된 사용자 사용자 정의 타입에 대해 피클 모듈을 지원합니다. 5,queue 모듈은 생산자 소비자 큐 (multi-producer, multi-consumer queue) 를 구현한다. 6. 소켓서버 모듈은 다양한 소켓서버를 구현하기 위한 일반적인 기본 클래스를 제공합니다. 7,configparser 모듈은 INI-style 프로파일을 분석하는 데 사용됩니다. 8,reprlib 모듈은 repr () 를 재 구현하고, 문자열 표시가 단절되기 전의 길이에 대한 컨트롤을 추가한다. 9부 프로세스 모듈은 하위 프로세스를 만들고, 그들의 파이프에 연결하고, 그들의 반환 값을 얻을 수 있도록 합니다.
패키지는 서로 연관된 모듈들의 그룹으로 구성된 단일 실체이다. 파이썬 2에서는 동일한 패키지 내 모듈의 상호 참조를 구현하기 위해 import foo 또는 from foo import Bar를 사용한다.2解释器会先在当前目录里搜索foo.py파이썬 3에서는 이 과정이 약간 다릅니다. 파이썬 3는 현재 경로에서 먼저 검색하지 않고 파이썬의 검색 경로에서 직접 검색합니다. 만약 패키지의 한 모듈이 다른 모듈을 파키지에서 가져오기를 원한다면, 두 모듈의 상대 경로를 명시적으로 제공해야 합니다.
만약 여러분이 이 패키지를 가지고 있고, 같은 디렉토리에 여러 개의 파일을 가지고 있다고 가정해보세요.
차르데트/ 자, 이제 시작해보죠. ±-init.py 자, 이제 시작해 봅시다.+--constants.py | +--mbcharsetprober.py | +--유니버설 디렉터.py
이제 UniversalDetector.py가 전체 constants.py를 가져와야 한다고 가정해 봅시다.，另外还需要导入mbcharsetprober.py的一个类。你会怎样做?
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 수입 상수 | .import 상수에서 |
| ② | mbcharsetprober에서 가져오기 MultiByteCharSetProber | .mbcharsetprober에서 가져오기 MultiByteCharsetProber |
1, 패키지의 다른 곳에서 전체 모듈을 가져오기 위해 새로운 from.import 문법을 사용하십시오. 여기서의 정자 ((.) 는 현재 파일을 나타냅니다.universaldetector.py이 문서의 문서는constants.py이 예제에서는 두 파일이 같은 디렉토리에 있기 때문에 단절을 사용합니다. 또한 부모 디렉토리 ((from... import anothermodule) 에서 또는 하위 디렉토리에서 수입할 수 있습니다. 2. 다른 모듈에서 특정 클래스 또는 함수를 직접 네임스페이스에 가져오기 위해 가져오기 원하는 모듈의 앞에는 상대 경로를 추가하고 마지막 슬래시를 제거한다. 이 예에서, mbcharsetprober.py와 universaldetector.py는 같은 디렉토리에 있으므로 상대 경로 이름은 문장이다. 또한 부모 디렉토리 (from... import anothermodule) 또는 하위 디렉토리에서 가져오기도 한다.
파이썬 2에서는 이더리어가 다음을 반환하기 위해 다음의 () 방법을 가지고 있습니다. 파이썬 3에서는 동일하게 작동하지만 이제 새로운 범용 함수가 있습니다. 이더리어가 변수로 사용되는 다음 () 함수입니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | anIterator.next (() | 다음 (Aniterator) |
| ② | a_function_that_returns_an_iterator().next() | next ((a_function_that_returns_an_iterator()) |
| ③ | 클래스 A: def next(self): 통과 |
클래스 A: def _다음(자신): |
| ④ | 클래스 A: def next ((self, x, y): 통과 |
변경되지 않습니다. |
| ⑤ | next = 42 이터레이터의 a_sequence_of_iterators에서 an_iterator에 대한: an_iterator.next (() |
next = 42 이터레이터의 a_sequence_of_iterators에서 an_iterator에 대한: an_iterator._다음() |
1, 가장 간단한 예로, 당신은 이제 반복자의 next() 방법을 호출하지 않고, 당신은 이제 반복자의 자체를 범용 함수 next() 로 매개로 전달합니다. 2, 만약 당신이 반환 값이 반복자의 함수인 경우, 이 함수를 호출하고 그 결과를 다음 () 함수에 매개변수로 전달한다. 3.. 만약 당신이 자신의 클래스를 가정하고 그것을 반복자로 사용한다면, 파이썬 3에서는 특별한 방법을 정의하여다음(개발자) 4, 만약 정의된 클래스 안에 네크스트 (next) 가 있는 경우, 그것은 하나 이상의 매개 변수를 사용한다. 2to3가 실행할 때 움직이지 않는다. 이 클래스는 네크스트 (next) 메소드가 매개 변수를 가지고 있기 때문에 이더리어로 사용될 수 없다. 5, 이건 좀 복잡합니다. 만약 여러분이 네크스트라는 로컬 변수를 가지고 있다면, 파이썬 3에서는 네크스트라는 범용 함수보다 더 높은 우선 순위를 갖게 됩니다. 이 경우, 여러분은 이더리터의 특별한 방법을 호출해야 합니다.다음() 를 통해 다음 요소를 얻을 수 있습니다. 또는, 당신은 코드를 재구성하여 이 로컬 변수의 이름을 다음으로 만들 수 있습니다. 하지만 2to3는 당신을 위해 그것을 하지 않습니다.
파이썬 2의 filter (() 메소드는 true 또는 false를 반환하는 함수와 함께 일련의 모든 항목을 검사하는 리스트를 반환한다. 파이썬 3의 filter (() 함수는 리스트가 아닌 반복자를 반환한다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 필터 (a_function, a_sequence) | a_function, a_sequence) |
| ② | a_function, a_sequence) | 변경되지 않습니다. |
| ③ | 필터 ((무함, a_sequence) | [i for iin a_sequence if i] |
| ④ | 필터에 있는 i에 대한 ((아무도, a_sequence): | 변경되지 않습니다. |
| ⑤ | [i는 iin filter (a_function, a_sequence) 를 뜻한다] | 변경되지 않습니다. |
1, 가장 간단한 경우, 2to3는 list () 함수를 사용하여 filter () 를 포괄하고, list () 함수는 그것의 변수를 가로질러 리스트 () 를 반환합니다. 2, 그러나 filter ((() 호출이 list ((() 에 묶여있는 경우, 2to3는 더 이상 처리하지 않습니다. 이 경우 filter ((() 의 반환 값이 반복자인지 여부는 중요하지 않습니다. 3, filter ((None,...) 와 같은 특수한 문법을 처리하기 위해, 2to3는 이러한 호출을 문법적으로 동등하게 리스트 분석으로 변환합니다. 4. for 루프는 전체 시퀀스를 가로질러 이동하기 때문에 더 이상 수정할 필요가 없습니다. 5, 위와 마찬가지로, 변경할 필요가 없습니다. 목록 분석이 전체 순서로 진행되기 때문에, 필터 () 가 반복자를 반환하더라도 이전 필터 () 가 목록을 반환하는 것처럼 정상적으로 작동합니다.
필터 ((() 의 변경과 마찬가지로, map ((() 함수는 이제 반복자를 반환합니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | map ((a_function, |
목록 (지도) (기능) |
| ② | 지도 (아무도, |
목록 ( |
| ③ | map ((lambda x: x+1,range ((42)) | [x+1에 대한 x 범위에서 ((42) ] |
| ④ | map (a_function, a_sequence) 에서 i를 위해: | 변경되지 않습니다. |
| ⑤ | [i for iin map ((a_function,a_sequence) ] | 변경되지 않습니다. |
1, 필터 (,) 와 유사한 처리, 가장 간단한 경우, 2to3는 list () 함수를 사용하여 map () 호출을 포괄합니다. 2、 특수한 map ((None,...) 문법과 filter ((None,...) 와 비슷하게, 2to3는 그것을 사용된 list (((의 동등한 호출으로 변환합니다. 3, 만약 map의 첫 번째 변수가 람브다 함수라면, 2to3는 이를 동등하게 리스트 해독으로 변환한다. 4, 전체 행을 가로질러 가는 for 루프에 대해서는 변경할 필요가 없습니다. 5. 다시 말하지만, 여기에 변경할 필요가 없습니다. 왜냐하면 목록 분석은 전체 시퀀스를 가로지르기 때문에, map ((() 의 반환 값이 목록이 아닌 반복자일지라도 정상적으로 작동합니다.
파이썬 3에서,reduce () 함수는 글로벌 네임스페이스에서 제거되었으며, 현재 fucntools 모듈에 배치되어 있다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 감소 (a, b, c) | 기능 도구 수입 감소 감소 (a, b, c) |
파이썬 2에는 global function (apply) 라는 global function이 있는데, 이 function (f) 와 list (a, b, c) 를 매개 변수로 사용해서 f (a, b, c) 를 반환한다. 이 function (f) 를 직접 호출하여 리스트 앞에 별자리 (*) 를 붙여서 매개 변수로 전달하는 것만으로도 같은 작업을 수행할 수 있다. 파이썬 3에서는 apply (() 함수가 존재하지 않는다. 별자리 표기법을 사용해야 한다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 적용 (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) |
| ③ | 적용 (a_function, a_list_of_args+ z) | a_function ((*a_list_of_args+ z) |
| ④ | 적용 (aModule.a_function, a_list_of_args) | aModule.a_function (a_list_of_args) |
1, 가장 간단한 형태로, 함수를 호출하기 위해 변수 목록 (([a, b, c]처럼) 앞에 별자리를 추가하면 된다. 이것은 파이썬 2의 apply ((() 함수와 동등하다. 2, 파이썬 2에서, apply() 함수는 실제로 3개의 매개 변수를 가질 수 있다: 하나의 함수, 하나의 매개 변수 목록, 하나의 사전 이름의 매개 변수 (dictionary of named arguments). 파이썬 3에서는 매개 변수 목록 앞에 별자리를 추가하여 매개 변수 목록의 앞부분에 별자리를 추가하여 매개 변수 목록의 앞부분에 별자리를 추가하여 매개 변수 목록의 앞부분에 별자리를 추가하여 매개 변수 목록의 앞부분에 별자리를 추가하여 매개 변수 목록의 앞부분에 별자리를 추가하여 매개 변수 목록의 앞부분에 별자리를 추가하여 매개 변수 목록의 앞부분에 별자리를 추가하여 매개 변수를 추가할 수 있다.), 사전 명칭 변수에 두 개의 별자리를 추가하여 동일한 효과를 얻습니다. 3, +는 연결 목록의 함수로서 사용되며, 이 함수보다 더 높은 우선 순위를 가지고 있습니다., 그래서 a_list_of_args + z 주위에 추가括号을 추가할 필요가 없습니다. 4, 2to3 스크립트는 모듈 내의 함수를 호출하는 것을 포함하여 복잡한 apply () 호출을 변환하기에 충분히 똑똑합니다.
파이썬 2에서는 intern () 함수를 문자열에 제한하여 성능 최적화를 달성할 수 있습니다. 파이썬 3에서는 intern () 함수가 sys 모듈로 옮겨집니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | intern ((aString) | sys.intern (aString) |
프린트 문장이 파이썬 3에서 함수로 변하는 것과 마찬가지로 exec 문장도 마찬가지이다. ▲exec () 함수는 임의의 파이썬 코드를 포함하는 문자열을 매개 변수로 사용하고 실행 문장이나 표현처럼 실행합니다. ▲exec () 는eval () 와 비슷하지만 exec () 는 더 강력하고 더 세련되어 있습니다. ▲eval () 함수는 단 하나의 표현식을 수행 할 수 있지만 exec () 는 여러 문장을 수행 할 수 있습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | exec 코드String | exec ((코드String) |
| ② | exec 코드 a_global_namespace에 있는 문자열 | exec ((코드String, a_global_namespace) |
| ③ | exec 코드 a_global_namespace, a_local_namespace에 있는 문자열 | exec ((코드String, a_global_namespace,a_local_namespace) |
1, 가장 간단한 형태로, exec ((() 는 이제 문장이 아닌 함수이기 때문에, 2to3는 이 문자열 형태의 코드를 괄호로 둘러싸고 있습니다. 2. 파이썬 2의 exec 문장은 네임스페이스를 지정할 수 있으며, 코드는 이 전 세계 객체들로 구성된 프라이빗스페이스에서 실행될 것이다. 파이썬 3에서도 이런 기능이 있습니다. 당신은 이 네임스페이스를 두 번째 파라그램으로 exec ()) 함수에게 전달할 필요가 있습니다. 3, 더욱 놀라운 것은 파이썬 2의 exec 문장이 로컬 네임스페이스 (예를 들어 함수에서 선언된 변수) 를 지정할 수 있다는 것입니다.
이전 exec 문장과 마찬가지로, 파이썬 2의 execfile 문장은 파이썬 코드를 실행하는 것처럼 문자열을 사용할 수 있습니다. exec가 문자열을 사용하고 execfile가 파일을 사용하는 것과는 다릅니다. 파이썬 3의 execfile 문장은 이미 제거되었습니다. 만약 당신이 정말로 파일에 있는 파이썬 코드를 실행하기를 원한다면 (하지만 당신은 그것을 가져오지 않으려면) 당신은 이 파일을 열고 내용을 읽고, 그 다음 컴파일 (compile) 범용 함수를 호출하여 새로운 exec 함수를 호출할 수 있습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | execfile (( |
exec(compile(open( |
파이썬 2에서는 임의의 객체를 문자열로 표현하기 위해 객체를 반항으로 포장하는 방법이 있습니다.x) 의 특수한 문법. 파이썬 3에서는 이러한 기능이 여전히 존재하지만, 더 이상 반추호를 사용하여 이러한 문자열을 나타낼 수 없습니다. 당신은 범용 함수 repr ((() 를 사용해야합니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | `x` | repr ((x) |
| ② | ` |
1, x는 어떤 것도 될 수 있다는 것을 기억하십시오.
파이썬 2에서 파이썬 3에 걸쳐서 특이한 것을 캡처하는 문법은 약간 달라질 수 있습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | try: import mymodule except ImportError, e 를 통과 |
try: import mymodule e: 를 통과 하 여 ImportError를 제외하고 |
| ② | try: import mymodule except (RuntimeError, ImportError), e pass |
try: import mymodule except (RuntimeError, ImportError) 를 e: 가 통과하면 |
| ③ | try: import mymodule except ImportError: pass |
변경되지 않습니다. |
| ④ | try: import mymodule except: pass |
변경되지 않습니다. |
1, 파이썬 2에서 예외 타입 뒤에 코마를 추가하는 것과는 달리, 파이썬 3에서는 새로운 키워드를 사용한다. 2, as 키워드는 한 번에 여러 종류의 오차를 캡처하는 경우에도 사용할 수 있습니다. 3, 만약 당신이 예외를 잡았지만 예외의 객체 자체를 접근하는 것을 원하지 않는다면, 파이썬 2와 파이썬 3의 문법은 동일합니다. 4. 마찬가지로, 만약 당신이 모든 예외들을 포착하기 위해 방역방법 (fallback) 을 사용한다면, 파이썬 2와 파이썬 3의 문법은 동일합니다. 5. 모듈 (또는 대부분의 경우) 를 수입할 때, 당신은 절대적으로 이 방법을 사용하지 말아야 한다. 그렇지 않으면, 프로그램이 키보드 인터럽트 (사용자가 Ctrl-C를 누르면 프로그램을 인터럽트하면) 와 같은 예외를 포착하여 디버깅을 더 어렵게 할 수 있다.
파이썬 3에서, 사용자 정의 특이한 문법을 던지는 데 약간의 변화가 있습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | MyException를 올립니다. | 변함없이 |
| ② | MyException를 올립니다. | raise MyException (MyException) |
| ③ | MyException, |
raise MyException (( |
| ④ | 지원되지 않는 |
1, 사용자가 사용자 정의 오류 정보를 가지고 있지 않은 예외를 던지는 것, 그 가장 간단한 형태로 문법은 변경되지 않습니다. 2. 사용자가 사용자 지정 오류를 가지고 있는 예외를 던지고 싶을 때 변경하는 것은 분명하다. 2. 파이썬은 오차와 오류를 코마로 구분하고, 3. 파이썬은 오류를 파라미터로 전달한다. 3. 파이썬 2에서는 사용자 사용자 정의 스택 트레이스를 가진 예외를 던지는 더 복잡한 문법을 지원합니다. 파이썬 3에서는 그렇게 할 수 있지만 문법은 완전히 다릅니다. 4. 파이썬 2에서는 예외가 없는 예외를 던져서 예외 메시지가 하나만 있을 수 있습니다. 파이썬 3에서는 이러한 형태가 더 이상 지원되지 않습니다. 2to3는 이러한 문법을 자동으로 수정할 수 없다는 경고를 합니다.
파이썬 2에서는 생성자가 a_generator.throw (a_generator.throw) 를 호출하여 생성자가 일시 중지될 때 예외를 던지고 생성자 함수에서 얻은 다음 값을 반환합니다. 파이썬 3에서는 이 기능이 여전히 사용 가능하지만 문법적으로 약간 다릅니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | a_generator.throw (MyException) | 변경되지 않습니다. |
| ② | a_generator.throw ((MyException, |
a_generator.throw ((MyException)) |
| ③ | a_generator.throw (( |
지원되지 않는 |
1, 가장 간단한 형태로 생성자는 사용자가 사용자 정의 오류 메시지를 가지고 있지 않은 예외를 던집니다. 이 경우 Python 2에서 Python 3로 문법적으로 변경되지 않습니다. 2, 생성자가 사용자 사용자 지정 오류 메시지가 있는 예외를 던지면, 당신은 이 오류 메시지의 문자열을 예외 클래스에 전달하여 이를 사례화할 필요가 있다. 3, 파이썬 2는 예외 정보만을 던지는 예외를 지원합니다. 파이썬 3는 이러한 문법을 지원하지 않으며, 2to3는 이 코드를 수동으로 수정해야 한다는 경고 메시지를 표시합니다.
파이썬 2에서는 특정 범위의 숫자를 얻기 위해 두 가지 방법이 있습니다: range ((), 그것은 목록을 반환하고 range ((), 그것은 반복자를 반환합니다. 파이썬 3에서는 range (() 는 반복자를 반환하고 xrange (() 는 더 이상 존재하지 않습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | xrange ((10) | 범위 ((10) |
| ② | a_list = 범위 ((10) | a_list = list ((range)) |
| ③ | [i 인 x 범위를 위해 (i) 10) ] | [내 범위에 대한 i (i) ] |
| ④ | 범위에 있는 i (i) 에 대해: | 변경되지 않습니다. |
| ⑤ | 총액 (범위) | 변경되지 않습니다. |
1, 가장 간단한 경우, 2to3는 xrange (xrange) 를 range (range) 로 간단히 변환합니다. 2, 만약 당신의 파이썬 2 코드가 range를 사용한다면, 2to3는 당신이 리스트를 필요로 하는지, 또는 반복자가 작동하는지 모른다는 것을 모른다. 조심스럽게, 2to3는 오류를 보고, list을 사용해서 range의 반환 값을 리스트 타입으로 강제로 변환할 수 있다. 3, 리스트解析에 xrange (xrange) 함수가 있는 경우, 리스트解析이 반복자에 대해서도 똑같이 유효하기 때문에 리스트로 반환값을 변환할 필요가 없다. 4, 마찬가지로, for 루킹은 아이러더에도 작용합니다, 그래서 여기도 아무것도 변경되지 않습니다. 5, sum () 함수는 이더리터에 작용할 수 있으므로 2to3도 여기에 변경되지 않습니다. 마치 값이 목록의 사전형 방법 대신 보기 (view) 로 반환되는 것과 마찬가지로, 이것은 min (min), max (max), sum (sum), list (list), tuple (tuple), set (set), sorted (sorted), any (any), all (all) 에 적용됩니다.
파이썬 2에는 명령줄에서 사용자가 입력하는 것을 요청하는 두 가지 범용 함수가 있습니다. 첫 번째는 입력이라고 불리며 사용자가 파이썬 표현을 입력하고 결과를 반환할 때까지 기다립니다. 두 번째는raw_input라고 불리며 사용자가 입력하는 것을 반환합니다. 이것은 초보자에게 매우 혼란스럽고 이는 널리 파이썬 언어의
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | raw_input (() | 입력 (() |
| ② | raw_input (( |
입력 ( |
| ③ | 입력 (() | 평가 (input) |
1, 가장 간단한 형태로,raw_input (()) 는 input (()) 로 대체됩니다. 2, 파이썬 2에서, raw_input () 함수는 지표로 지표를 지정할 수 있다. 파이썬 3에서는 이 함수를 유지한다. 3. 만약 당신이 정말로 사용자가 파이썬 표현식을 입력하도록 요청하고 싶다면, 결과를 계산할 수 있습니다.
파이썬 2에서는 함수의 코드가 함수의 특수한 속성에 접근할 수 있다. 파이썬 3에서는 일관성을 위해 이 특수한 속성이 명명되었다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | a_function.func_name | a_function._이름 |
| ② | a_function.func_doc | a_function._의사님 |
| ③ | a_function.func_defaults | a_function._기본값_ |
| ④ | a_function.func_dict | a_function._ |
| ⑤ | a_function.func_closure | a_function._폐업 |
| ⑥ | a_function.func_globals | a_function._글로벌_ |
| ⑦ | a_function.func_code | a_function._코드_ |
1,__name__ 속성 (原 function_name) 은 함수의 이름을 포함합니다. 2,__doc__ 속성 ((원래funcdoc) 은 함수의 소스 코드에서 정의한 문서 문자열 (docstring) 을 포함합니다 3, __defaults__ 속성 (原func_defaults) 은 함수의 기본값을 저장하는 요소군이다. 4,__dict__ 속성 (原 function_dict) 은 임의 함수 속성을 지원하는 이름 공간이다. 5,__closure__ 속성 (原 function_closure) 은 free variable에 대한 함수의 결합을 포함하는 cell 객체로 구성된 요소군이다. 6, __globals__ 속성 (原 function_globals) 은 모듈 전 세계 네임스페이스에 대한 참조이며 함수 자체는 네임스페이스에서 정의된다. 7, __code__ 속성 (原 function_code) 은 컴파일된 함수를 나타내는 코드 객체이다.
파이썬 2에서는 파일 객체에 xreadlines (xreadlines) 메소드를 가지고 있으며, 이는 반복자를 돌려서 한 번에 한 줄의 파일을 읽는다. 이것은 특히 for 루프에서 유용하다. 사실, 후속 파이썬 2 버전에서는 파일 객체 자체에 이러한 기능을 추가했다.
파이썬 3에서는 xreadlines (xreadlines) 방법이 더 이상 사용되지 않습니다. 2to3는 간단한 상황을 해결할 수 있지만 일부 가장자리 사례는 수동 개입이 필요합니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | a_file.xreadlines에 있는 줄에 대해: | a_file의 줄에 대해: |
| ② | a_file.xreadlines (a_file.xreadlines)) 의 줄에 대해: | 변경되지 않습니다 (파괴) |
1, 만약 당신이 이전에 변수 없는 xreadlines 를 호출했다면, 2to3는 그것을 파일 개체 자체로 변환한다. 파이썬 3에서는 이러한 변환 후 코드가 이전과 같은 작업을 수행할 수 있다. 파일의 한 줄을 한 번 읽고 for 루킹의 루킹을 실행한다.
2, 만약 당신이 이전에 한 변수를 사용했었다면 (읽기 횟수마다) xreadlines를 호출하는 경우 (), 2to3가 Python 2에서 Python 3로 변환을 완료하지 못하면, 당신의 코드는 다음과 같이 실패할 것이다: AttributeError:
파이썬 2에서는 익명의 람바다 함수를 정의할 수 있으며, 람바다 함수의 요소 개수를 매개 변수로 지정하여 함수가 실제로 여러 매개 변수를 받을 수 있게 한다. 사실, 파이썬 2의 해설자는 이 매개 변수를 이름의 매개 변수로 해독한다. 그러면 당신은 람바다 함수에서 이름을 통해 언급할 수 있다. 파이썬 3에서는 여전히 람바다 함수의 매개 변수로 매개 변수를 전달할 수 있지만, 파이썬 해설자는 그것을 이름의 매개 변수로 해설하지 않는다. 당신은 위치 인덱스를 통해 각각의 매개 변수를 참조해야 한다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 람다 (x,): x+ f (x) | 람다 x1: x1[0]+f(x1[0]) |
| ② | 람다 (x, y): x+f(y | 람다 x_y: x_y[0]+f(x_y[1]) |
| ③ | 람다 (x,(y,z)): x+ y+ z | 람다 x_y_z: x_y_z[0]+x_y_z[1][0]+ x_y_z[1][1] |
| ④ | 람다 x, y, z: x+y + z | 변함없이 |
1, 만약 당신이 람브다 함수를 정의했다면, 그것은 하나의 요소를 포함하는 계열을 파그램으로 사용한다. 파이썬 3에서는 x1[0]에 대한 참조를 포함하는 람브다 함수로 변환된다. x1은 원래 계열에 있는 명칭 파라그램에 기반한 2에서 3 스크립트의 자동 생성이다. 2, 두 개의 요소를 포함하는 계열 (x, y) 을 함수로 사용하는 람브다 함수는 x_y로 변환되며, 두 개의 위치 함수가 있습니다. x_y[0]와 x_y[1]. 3, 2to3 스크립트는 심지어 네이처 명칭 변수를 사용하는 구성 요소를 변수로 사용하는 람브다 함수를 처리할 수 있다. 생성된 결과 코드는 약간 읽기 어렵다. 그러나 이는 파이썬 3에서 원래 코드가 파이썬 2에서 했던 것과 동일한 효과를 발휘한다. 4, 여러 가지 함수를 사용하는 람브다 함수를 정의할 수 있다. 만약 함수를 둘레로括弧이 없다면, 파이썬 2는 그것을 여러 가지 함수를 포함하는 람브다 함수로 취급한다. 이 람브다 함수체에서는 다른 유형의 함수와 마찬가지로 이름을 통해 이 함수들을 참조한다. 이 문법은 파이썬 3에서 여전히 유효하다.
파이썬 2에서 클래스 메소드는 클래스 객체를 정의하는 데 액세스 할 수 있으며 메소드 객체 자체에도 액세스 할 수 있습니다. im_self는 클래스의 인스턴스 객체, im_func는 함수 객체, im_class는 클래스 자체입니다. 파이썬 3에서는 다른 속성의 명칭 협정을 따르기 위해 이러한 속성이 다시 명명됩니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | aClassInstance.aClassMethod.im_func | aClassInstance.aClassMethod._기능_ |
| ② | aClassInstance.aClassMethod.im_self | aClassInstance.aClassMethod._자기 |
| ③ | aClassInstance.aClassMethod.im_class | aClassInstance.aClassMethod._자기._클래스 |
파이썬 2에서는 자신의 클래스를 만들 수 있고, 이를 boolean context에서 사용할 수 있습니다. 예를 들어, 이 클래스를 인스턴스화하고 이 인스턴스 객체를 if 문장에서 사용할 수 있습니다. 이 목적을 달성하기 위해, 당신은 특별한 _를 정의합니다.0이 아닌() 메소드는 True 또는 False로 반환되며, 이 메소드는 예제 객체가 boolean 컨텍스트에 있을 때 호출됩니다. 파이썬 3에서는 여전히 같은 기능을 수행할 수 있지만 이 특별한 메소드의 이름이 바뀌었습니다.볼_()。
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 클래스 A: def _0이 아닌(self): 통과 |
클래스 A: def _볼_(self): 통과 |
| ② | 클래스 A: def _0이 아닌(자신, x, y): 통과 |
변경되지 않습니다. |
1,
파이썬 2와 파이썬 3 사이에는 8진수 (octal) 를 정의하는 문법의 약간의 변화가 있다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | x = 0755 | x = 0o755 |
전체형과 전체형이 통합됨에 따라 sys.maxint 상수는 더 이상 정확하지 않습니다. 그러나 이 값은 특정 플랫폼을 탐지하는 능력에 유용하기 때문에 Python 3에 의해 보존되어 sys.maxsize로 다시 명명되었습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | sys importmaxint에서 | sys importmaxsize에서 |
| ② | a_function (sys.maxint) | a_function (sys.maxsize) |
1,maxint는 maxsize로 바뀌었습니다. 2, 모든 sys.maxint는 sys.maxsize로 바뀌었다.
파이썬 2에서는 객체를 호출할 수 있는지 확인하기 위해 글로벌 함수 callable (callable, function) 를 사용할 수 있습니다. 파이썬 3에서는 이 글로벌 함수가 취소되었습니다. 객체를 호출할 수 있는지 확인하기 위해 특수 방법을 확인할 수 있습니다.전화( () 의 존재.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 소환 가능 (무엇든) | 아무 것도 없네전화’) |
파이썬 2에서, 범용 함수 zip ((() 은 임의의 여러 시퀀스를 파라그램으로 사용할 수 있으며, 그것은 계열로 구성된 목록을 반환한다. 첫 번째 계열은 각 계열의 첫 번째 요소를 포함하고, 두 번째 계열은 각 계열의 두 번째 요소를 포함하고, 순차적으로 밀어 내려간다. 파이썬 3에서, zip ((() 은 리스트가 아닌 반복자를 반환한다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | zip ((a, b, c) | 목록 (a, b, c) |
| ② | d.join ((zip ((a, b, c)) | 변경되지 않습니다. |
가장 간단한 형태로, zip () 함수의 이전 함수를 호출하여 zip () 함수의 반환값을 복원할 수 있습니다. list () 함수는 zip () 함수를 반환하는 반복기를 탐색하고 결과 목록 표시를 반환합니다. 이미 일련의 모든 요소를 탐색하는 문맥 환경에서 (예를 들어, 여기에 join () 방법을 호출하는 것) zip () 를 반환하는 반복자는 정상적으로 작동합니다. 2to3 스크립트는 이러한 상황을 감지하고 코드에 변경을 하지 않습니다.
파이썬 2에서는 스탠다드 에러가 스톱 이터레이션, 제너레이터 익시트, 키보드 인터럽트, 시스템 익시트 이외의 다른 모든 기본 클래스 내장 특이점이다. 파이썬 3에서는 스탠다드 에러가 폐지되었다. 예외를 사용한다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | x =StandardError (() | x = 예외입니다. |
| ② | x =StandardError ((a, b, c) | x = 예외 (a, b, c) |
types 모듈의 다양한 변수는 객체의 유형을 결정하는 데 도움이 된다. 파이썬 2에서는 모든 기본 데이터 타입을 대표하는 변수를 포함하고 있다. 예를 들어, dikt와 int. 파이썬 3에서는 이러한 변수가 이미 폐지되어 있다. 기본 타입의 이름을 사용해서만 대체할 필요가 있다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| types.UnicodeType | str | |
| types.StringType | 바이트 | |
| types.DictType | 디크트 | |
| types.IntType | int | |
| types.LongType | int | |
| types.ListType | 목록 | |
| types.NoneType | 타입 (무함) | |
| types.BooleanType | bool | |
| types.BufferType | 메모리뷰 | |
| types.ClassType | 종류 | |
| types.ComplexType | 복합적 | |
| types.EllipsisType | 타입 ( |
|
| types.FloatType | 플라트 | |
| types.ObjectType | 물체 | |
| types.NotImplementedType | 타입 (실제되지 않았습니다) | |
| types.SliceType | 슬라이스 | |
| types.TupleType | 튜플 | |
| types.TypeType | 종류 | |
| types.XRangeType | 범위 |
types.StringType는 str가 아닌 바이트로 매핑되기 때문에, 파이썬 2의
isinstance () 함수는 객체가 특정 클래스 (class) 또는 타입 (type) 의 인스턴스인지 여부를 검사한다. 파이썬 2에서는 타입 (types) 으로 구성된 계열을 이인스턴스 (isinstance) 에 전달할 수 있으며, 객체가 계열의 임의의 타입이라면 함수는 True를 반환한다. 파이썬 3에서는 여전히 그렇게 할 수 있지만, 같은 타입을 두 번으로 전달하는 것은 권장하지 않는다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| 이 인스턴스 (x,int,float,int) | 이 인스턴스 (x,int,float) |
파이썬 2에는 두 가지 문자열 유형이 있습니다. 유니코드 코딩된 문자열과 유니코드 코딩되지 않은 문자열. 그러나 실제로는 또 다른 유형이 있습니다. 그것은 추상 데이터 타입이며 str와 유니코드 타입의 슈퍼 클래스입니다. 그것은 직접 호출되거나 예시화 될 수 없습니다. 그러나 당신은 객체가 유니코드 문자열 또는 비 유니코드 문자열인지 검증하기 위해 객체 인스턴스 (instance) 로 사용할 수 있습니다. 파이썬 3에서는 하나의 문자열 유형이 있습니다. 따라서 바세스트링은 더 이상 존재하지 않습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| isinstance ((x, 기본string) | isinstance ((x, str) |
파이썬 2.3에서는 이터툴스 모듈을 도입하여, 이터툴스 모듈에 있는 이터툴스 함수들은 이터툴스 모듈에 있는 이터툴스 함수들 중 이터툴스 함수들 뿐만 아니라 이터툴스 모듈에 있는 다른 많은 유용한 함수들이 여전히 존재하기 때문에 이터툴스 3에서는 이터툴스 함수들의 이터툴스 함수가 제거되었다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | itertools.izip (a, b) | zip ((a, b) |
| ② | itertools.imap (a, b) | 지도 (a, b) |
| ③ | itertools.ifilter (a, b) | 필터 (a, b) |
| ④ | itertools에서 IMAP, izip, foo를 가져옵니다. | itertools에서 foo를 가져오기 |
1、itertools.izip() 를 대신하여 전 세계적인 zip ((() 함수를 사용한다. 2、 itertools.imap의 대신 map을 사용하라. 3,itertools.ifilter ((() 는 필터 ((() 로 바뀌었다. 4·itertools 모듈은 파이썬 3에 여전히 존재하지만, 더 이상 범용 네임스페이스로 이동된 함수를 포함하지 않습니다. 2to3 스크립트는 더 이상 쓸모없는 입장을 제거할 수 있을 만큼 똑똑하지만 다른 입장을 유지합니다.
예외를 처리할 때, sys 모듈에서 접근할 수 있는 세 가지 변수가 있다. sys.exc_type, sys.exc_value, sys.exc_traceback. 실제로는 Python 1시대에는 이러한 변수가 있었다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| sys.exc_type | sys.exc_info (() [0] | |
| sys.exc_value | sys.exc_info (() [1] | |
| sys.exc_traceback | sys.exc_info (() [2] |
파이썬 2에서는, 만약 당신이 요소를 횡단하는 리스트 분석을 작성할 필요가 있다면, 당신은 요소 값 주위에 괄호를 추가할 필요가 없다. 파이썬 3에서는, 이러한 괄호가 필수적이다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| [i 인 1,2] | [i는 iin(1,2) 를 나타냅니다] |
파이썬 2에는 현재 작업 디렉토리를 os.getcwd ((() 라고 부르는 함수가 있습니다. 현재 작업 디렉토리를 유니코드로 코딩된 문자열로 반환합니다. 현대 파일 시스템이 어떤 문자를 코딩할 수 있는 디렉토리 이름을 처리할 수 있기 때문에, 파이썬 2.3에서는 os.getcwdu ((() 함수를 도입했습니다. os.getcwdu ((() 함수가 현재 작업 디렉토리를 유니코드로 코딩된 문자열로 반환합니다. 파이썬 3에서는 단 하나의 문자열이 있기 때문에 os.getcwd ((() 가 필요합니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| os.getcwdu (() | os.getcwd (() |
파이썬 2에서는 클래스의 선언에서 메타클래스 매개 변수를 정의하거나, 특별한 클래스 레벨의 (class-level) __metaclass__ 속성을 정의하여 메타클래스를 만들 수 있습니다. 파이썬 3에서는 __metaclass__ 속성이 삭제되었습니다.
| 참고문서 | 파이썬 2 | 파이썬 3 |
|---|---|---|
| ① | 클래스 C (메타클래스=PapayaMeta): 통과 |
변함없이 |
| ② | 클래스 화이트:메타클래스= 파파야 메타 | 클래스 윙 (Metaclass=PapayaMeta): 통과 |
| ③ | 클래스 C (비치퍼, 비터):메타클래스= 파파야 메타 | 클래스 C ((Whipper,Beater,metaclass=PapayaMeta): 통과 |
1, 클래스를 선언할 때 메타클래스参数을 선언하는 것, 이는 Python 2와 Python 3에서 모두 유효합니다. 그들은 동일합니다. 2, 클래스의 정의에서 __metaclass__ 속성이 파이썬 2에서 유효하지만 파이썬 3에서는 유효하지 않다고 선언한다. 3, 2to3는 클래스가 여러 개의 부모 클래스에서 계승되더라도 유효한 클래스 선언을 만들 수 있습니다.
아래의 수정 사항들은 실질적으로 진정한 수정 사항은 아닙니다. 즉, 그것들은 코드 스타일에 관한 것 뿐이며 코드의 본질에 관여하지 않습니다. 그러나 파이썬 개발자들은 코드 스타일을 가능한 한 일관되게 만드는 데 매우 관심이 있습니다. 이를 위해, 파이썬 코드 스타일을 설명하는 공식 지침서가 있습니다.
파이썬 2에서 문자값 집합 (literal set) 을 정의하는 유일한 방법은 set (a_sequence) 를 호출하는 것이다. 파이썬 3에서는 이것은 여전히 유효하지만 새로운 문자 표기 (literal notation) 를 사용하는 것이 더 명확한 방법이다. 이 방법은 빈 집합 이외에도 유효합니다. 왜냐하면 사전도 빈 집합이 아닌 빈 집합을 표시하기 때문에 {}는 빈 사전을 나타냅니다.
2to3 스크립트는 기본적으로 set ((() 문자값을 수정하지 않습니다. 이 기능을 활성화하려면 명령줄에서 2to3을 호출할 때 -f set_literal 변수를 지정합니다.
| 참고문서 | 이전 | 그 후 |
|---|---|---|
| 세트 (([1,2,3]) | {1,2,3} | |
| 세트 (((1,2,3)) | {1,2,3} | |
| set (([i for iin a_sequence]) | {i for iin a_sequence} |
C에서 구현된 파이썬 객체는 다른 파이썬 코드가 메모리를 직접 읽거나 쓸 수 있도록 허용하는
2to3 스크립트는 기본적으로 buffer ()) 함수를 수리하지 않습니다. 이 함수를 활성화하려면 명령 줄에서 2to3을 호출할 때 -f buffer 변수를 지정합니다.
| 참고문서 | 이전 | 그 후 |
|---|---|---|
| x = 버퍼 (y) | x = 메모리 뷰 (y) |
비록 파이썬은 인덴팅과 아웃덴팅을 위한 공간에 대한 엄격한 요구사항을 가지고 있지만, 파이썬은 다른 측면에서의 공간 사용에 대해 자유롭다. 목록, 계열, 집합 및 사전에서, 스페이스가 코마 앞에 또는 뒤에 나타날 수 있으며, 이것은 나쁜 영향을 미치지 않는다. 그러나, 파이썬 코드 스타일 지침서는 코마 앞에 스페이스가 있을 수 없으며, 코마 뒤에 스페이스가 포함되어야 한다고 지적한다. 비록 이것은 순수하게 미적 고려의 코드일지라도 정상적으로 작동할 수 있고, 파이썬 2와 파이썬 3에서 가능하지만, 2to3 스크립트는 설명서의 기준에 따라 당신을 위해 이 수정을 수행할 수 있다.
2to3 스크립트는 기본적으로 코마 주위의 공간을 수정하지 않습니다. 이 기능을 활성화하려면 명령 줄에서 2to3를 호출할 때 -f wscomma 변수를 지정합니다.
| 참고문서 | 이전 | 그 후 |
|---|---|---|
| a,b | a, b | |
| {a:b} | {a: b} |
파이썬 커뮤니티에서 많은 관례가 구축되어 있다. 예를 들어 while 1: loop는 파이썬 1으로 거슬러 올라간다. 파이썬은 파이썬 2.3까지 진정한 의미의 풀 타입을 가지지 않았기 때문에 개발자는 이전에는 1과 0을 대체했다. 현대 파이썬 프로그래머는 이러한 관습을 사용하는 현대 버전의 두뇌를 훈련해야 한다.
2to3 스크립트는 기본적으로 이러한 관습을 수정하지 않습니다. 이 기능을 활성화하려면 명령 줄에서 2to3를 호출할 때 -f idioms 변수를 지정합니다.
| 참고문서 | 이전 | 그 후 |
|---|---|---|
| while 1: do_stuff() |
while True: do_stuff (() |
|
| 타입 ((x) == T | 이 경우 ((x, T) | |
| 타입 (x) 은 T | 이 경우 ((x, T) | |
| a_list = list (a_sequence) | a_list = 정렬된 (a_sequence) | |
| a_list.sort (() | do_stuff (사물 목록) | |
| do_stuff (사물 목록) |
번역주CSDN 블로그
Python 2.x의 코드를 Python 3.x의 코드로 변환하는 방법에 대한 설명. 파이썬 2.x 코드를 파이썬 3.x 코드로 변환하는 방법
이것은 단지 프린트 같은 몇 가지 함수만 포함한다면 말할 필요가 없습니다.
이 문서는 다른 문장과 같은 문장과도 관련이 있습니다.
파이썬 2.x 버전, 예를 들어 제가 설치한 파이썬 2.7.2, 윈도우에서 다운로드 받아 설치된 후 몇 가지 유용한 도구들을 가지고 있습니다.
其中一个叫做2to3.pyPython 2.x의 코드를 Python 3.x의 코드로 변환하는 것을 구현하는 데 도움이 됩니다.
이 파일은 Python 설치의 루트 디렉토리\Python27\Tools\Scripts\2to3.py에 있습니다.
【如何利用2to3.py, 파이썬 2.x의 코드를 파이썬 3.x의 코드 탭으로 변환하는 것을 구현합니다 예를 들어, 저는 파이썬 2.x의 파이썬 스크립트를 가지고 있습니다.
D:\tmp\tmp_dev_root\python\python2_to_python3\34563264_site.py에서 데이터
이제, 이것을 파이썬 3.x의 코드로 변환하고자 합니다.
windows의 cmd를 열고, 변환하려는 스크립트에 위치하여 실행할 수 있습니다.
D:\tmp\WordPress\DevRoot\Python27\Tools\Scripts\2to3.py -w 34563264_data_from_site.py
만약 이 변환이 성공한다면, 해당 실행 결과는:
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
이 시점에서, 당신은 원래의 34563264_data_from_site.py를 볼 수 있습니다.
FangBeibotvs가 사용하는 Python2?
발명가들의 수량화 - 작은 꿈BotVS의 검색 서버는 Python 2.7 버전을 사용하며 BotVS 플랫폼 Python2와 Python3 모두 지원됩니다.