Python Language
Python 2에서 Python 3로 옮겨가는 비 호환성

소개

비고

from __future__ import print_function
# other imports and instructions go after __future__
print('Hello world')

인쇄 문 대 인쇄 기능

파이썬 2에서 print 는 다음과 같은 문장입니다 :

print "Hello World"
print                         # print a newline
print "No newline",           # add trailing comma to remove newline 
print >>sys.stderr, "Error"   # print to stderr
print("hello")                # print "hello", since ("hello") == "hello"
print()                       # print an empty tuple "()"
print 1, 2, 3                 # print space-separated arguments: "1 2 3"
print(1, 2, 3)                # print tuple "(1, 2, 3)"

파이썬 3에서 print() 는 일반적인 용도의 키워드 인자를 가진 함수이다.

print "Hello World"              # SyntaxError
print("Hello World")
print()                          # print a newline (must use parentheses)
print("No newline", end="")      # end specifies what to append (defaults to newline)
print("Error", file=sys.stderr)  # file specifies the output buffer
print("Comma", "separated", "output", sep=",")  # sep specifies the separator
print("A", "B", "C", sep="")     # null string for sep: prints as ABC
print("Flush this", flush=True)  # flush the output buffer, added in Python 3.3
print(1, 2, 3)                   # print space-separated arguments: "1 2 3"
print((1, 2, 3))                 # print tuple "(1, 2, 3)"

인쇄 기능에는 다음과 같은 매개 변수가 있습니다.

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

sep 는 사용자가 인쇄하기 위해 전달한 객체를 구분합니다. 예 :

print('foo', 'bar', sep='~') # out: foo~bar
print('foo', 'bar', sep='.') # out: foo.bar

end 은 print 서술문의 끝에 오는 문자입니다. 예 :

print('foo', 'bar', end='!') # out: foo bar!

같은 줄에 인쇄 할 인쇄 문을 종료되지 않은 줄 바꿈 다음 다시 인쇄 :

print('foo', end='~')
print('bar')
# out: foo~bar

참고 : 향후 호환을 위해 print 기능 은 Python 2.6 이상에서도 사용할 수 있습니다. 그러나 print 서술문의 구문 분석이 비활성화되어 있지 않으면 사용할 수 없습니다.

from __future__ import print_function

이 함수는 flush 매개 변수가 없다는 점을 제외하고는 Python 3과 완전히 동일한 형식입니다.

이론적 근거는 PEP 3105 를 참조하십시오.

문자열 : 바이트 대 유니 코드

s = 'Cafe'    # type(s) == str

s = u'Café'   # type(s) == unicode
b = 'Lorem ipsum'  # type(b) == str

from __future__ import unicode_literals

s = 'Café'   # type(s) == unicode
b = 'Lorem ipsum'  # type(b) == unicode

isinstance(s, basestring)

s = 'Cafe'           # type(s) == str
s = 'Café'           # type(s) == str (note the accented trailing e)

# Or, if you really need a byte string:
s = b'Cafe'          # type(s) == bytes
s = 'Café'.encode()  # type(s) == bytes

isinstance(s, str)

u'Cafe' == 'Cafe'

>>> ur'Café'
  File "<stdin>", line 1
    ur'Café'
           ^
SyntaxError: invalid syntax

Python 3 text ( str ) 객체를 encode 하여 해당 텍스트의 bytes 표현으로 변환해야합니다. 이 메소드의 기본 인코딩은 UTF-8 입니다.

decode 를 사용하여 bytes 객체에 어떤 유니 코드 텍스트가 나타나는지 질문 할 수 있습니다.

>>> b.decode()
'Café'

from __future__ import unicode_literals
print(repr("hi"))
# u'hi'

b"abc"[0] == 97

b"abc"[0:1] == b"a"

또한 Python 3은 유니 코드로 일부 비정상적인 동작 을 수정합니다 . 즉, Python 2에서 바이트 문자열을 뒤집습니다. 예를 들어 다음 문제 가 해결되었습니다.

# -*- coding: utf8 -*-
print("Hi, my name is Łukasz Langa.")
print(u"Hi, my name is Łukasz Langa."[::-1])
print("Hi, my name is Łukasz Langa."[::-1])

# Output in Python 2
# Hi, my name is Łukasz Langa.
# .agnaL zsakuŁ si eman ym ,iH
# .agnaL zsaku�� si eman ym ,iH

# Output in Python 3
# Hi, my name is Łukasz Langa.
# .agnaL zsakuŁ si eman ym ,iH
# .agnaL zsakuŁ si eman ym ,iH

정수 부

표준 구분 기호 ( / )는 정수에 적용될 때 Python 3 및 Python 2에서 다르게 작동합니다.

파이썬 3에서 정수를 다른 정수로 나눌 때, 나눗셈 연산 x / y 는 __truediv__ 나누기 ( __truediv__ 메서드 사용)를 __truediv__ 부동 소수점 결과를 생성합니다. 한편, Python 2에서의 동일한 연산은 결과를 무한대로 반올림하는 고전적인 부분 을 나타냅니다 ( 바닥 을 차지하는 것으로도 알려짐).

예 :

0으로 반올림하는 동작은 Python 2.2 에서 더 이상 사용되지 않지만 이전 버전과의 호환성을 위해 Python 2.7에 남아 있으며 Python 3에서는 제거되었습니다.

참고 : 파이썬 2에서 플로팅 결과를 얻으려면 (바닥 라운딩없이) 피연산자 중 하나를 소수점으로 지정할 수 있습니다. 위의 Python 2에서 0 을 제공하는 2/3 예는 2 / 3.0 또는 2.0 / 3 또는 2.0/3.0 되어 0.6666666666666666

두 버전 모두에서 같은 방식으로 작동하는 바닥 나누기 연산자 ( // )가 있습니다. 가장 가까운 정수로 내림합니다. (float와 함께 사용하면 float가 반환되지만) 두 버전 모두에서 // 연산자는 __floordiv__ 매핑됩니다.

operator 모듈에서 고유 함수를 사용하여 명시 적으로 실제 나누기 또는 바닥 나누기를 적용 할 수 있습니다.

from operator import truediv, floordiv
assert truediv(10, 8) == 1.25            # equivalent to `/` in Python 3
assert floordiv(10, 8) == 1              # equivalent to `//`

명확하고 명확한 반면, 모든 부서에 대해 연산자 기능을 사용하는 것은 지루할 수 있습니다. / 연산자의 동작을 변경하는 것이 종종 선호됩니다. 일반적인 방법은 from __future__ import division 을 각 모듈의 첫 번째 명령문으로 추가하여 일반적인 나누기 동작을 제거하는 것 from __future__ import division .

# needs to be the first statement in a module
from __future__ import division

from __future__ import division 은 / 연산자가 __future__ 가져 오기가 포함 된 모듈 내에서만 true 나눗셈을 나타냄을 보장하므로 모든 새 모듈에서 / not 연산자를 활성화하지 않을 이유가 없습니다.

참고 : 다른 프로그래밍 언어는 파이썬처럼 (즉, -3 / 2 == -1 과 같은 ) 음의 무한대 로 반올림 하지 않고 제로 ( 반올림) 로 반올림을 사용합니다. 이 동작은 코드를 이식하거나 비교할 때 혼란을 야기 할 수 있습니다.

float 피연산자에 대한 참고 사항 : from __future__ import division 사용하는 대신 일반 분할 기호 / 를 사용하여 피연산자 중 적어도 하나가 float : 3 / 2.0 == 1.5 있습니다. 그러나 이것은 나쁜 습관으로 간주 될 수 있습니다. average = sum(items) / len(items) 을 쓰고 인수 중 하나를 float으로 만드는 것을 잊어 버리는 것은 너무 쉽습니다. 더욱이, 그러한 경우는 테스트 중에 예고를 피할 수 있습니다 (예 : float 포함 된 배열에서 테스트하지만 프로덕션에서 int 배열을받는 경우). 또한, 파이썬 3에서 동일한 코드가 사용된다면, 3 / 2 == 1 을 True로 기대하는 프로그램은 올바르게 작동하지 않을 것입니다.

파이썬 3에서 나눗셈 연산자가 변경된 이유와 구식 분할을 피해야하는 이유에 대한 자세한 설명은 PEP 238 을 참조하십시오.

나누기에 대한 자세한 내용은 간단한 수학 항목 을 참조하십시오.

Reduce는 더 이상 내장되어 있지 않습니다.

파이썬 2에서 reduce 는 내장 함수 또는 functools 패키지 (버전 2.6 이후)에서 사용할 수 있지만 파이썬 3에서는 reduce 를 functools 에서만 사용할 수 있습니다. 그러나 Python2와 Python3의 reduce 구문은 동일하며 reduce(function_to_reduce, list_to_reduce) 입니다.

예를 들어, 인접한 숫자 각각을 나눔으로써리스트를 단일 값으로 축소하는 것을 고려해 보자. 여기서 operator 라이브러리의 truediv 함수를 사용합니다.

파이썬 2.x에서는 다음과 같이 간단합니다 :

>>> my_list = [1, 2, 3, 4, 5]
>>> import operator
>>> reduce(operator.truediv, my_list)
0.008333333333333333

파이썬 3.x에서는 예제가 좀 더 복잡해졌습니다.

>>> my_list = [1, 2, 3, 4, 5]
>>> import operator, functools
>>> functools.reduce(operator.truediv, my_list)
0.008333333333333333

우리는 또한 from functools import reduce 를 사용하여 네임 스페이스 이름으로 reduce 를 호출하지 않도록 할 수 있습니다.

범위와 xrange 함수의 차이점

Python 2에서 range 함수는 목록을 반환하고 xrange 는 다른 내장 된 시퀀스 유형과 달리 불규칙한 시퀀스 인 특수 xrange 객체를 만들고 슬라이싱을 지원하지 않으며 index 또는 count 메소드도 가지고 있지 않습니다.

print(range(1, 10))
# Out: [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(isinstance(range(1, 10), list))
# Out: True

print(xrange(1, 10))
# Out: xrange(1, 10)

print(isinstance(xrange(1, 10), xrange))
# Out: True

Python 3에서 xrange 는 range 시퀀스로 확장되었으므로 이제 range 객체가 만들어집니다. xrange 유형이 없습니다.

print(range(1, 10))
# Out: range(1, 10)

print(isinstance(range(1, 10), range))
# Out: True

# print(xrange(1, 10))
# The output will be:
#Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#NameError: name 'xrange' is not defined

또한, 파이썬 3.2부터, range 는 또한 자르기, index 및 count 지원합니다 :

print(range(1, 10)[3:7])
# Out: range(3, 7)
print(range(1, 10).count(5))
# Out: 1
print(range(1, 10).index(7))
# Out: 6

리스트가 아닌 특수 시퀀스 타입을 사용하면 인터프리터가리스트를위한 메모리를 할당하고 그것을 채울 필요가 없다는 이점이있다.

# range(10000000000000000)
# The output would be:
# Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
# MemoryError

print(xrange(100000000000000000))
# Out: xrange(100000000000000000)

후자의 동작이 일반적으로 필요하기 때문에, 파이썬 3에서는 전자가 제거되었습니다. 여전히 파이썬 3에서리스트를 원한다면 range 객체에 list() 생성자를 간단히 사용할 수 있습니다 :

print(list(range(1, 10)))
# Out: [1, 2, 3, 4, 5, 6, 7, 8, 9]

적합성

Python 2.x와 Python 3.x 버전 사이의 호환성을 유지하기 위해 future 의 외부 패키지에서 builtins 모듈을 사용하여 순방향 호환성 과 역 호환성을 모두 얻을 수 있습니다 .

#forward-compatible
from builtins import range

for i in range(10**8):
    pass

#backward-compatible
from past.builtins import xrange

for i in xrange(10**8):
    pass

future 라이브러리의 range 는 Python 3.2 이상의 내장 메소드와 마찬가지로 모든 Python 버전에서 슬라이싱, index 및 count 를 지원합니다.

반복성 풀기

first, second, *tail, last = [1, 2, 3, 4, 5]
print(first)
# Out: 1
print(second)
# Out: 2
print(tail)
# Out: [3, 4]
print(last)
# Out: 5

first, second, *tail, last = [1, 2, 3, 4]
print(tail)
# Out: [3]

first, second, *tail, last = [1, 2, 3]
print(tail)
# Out: []
print(last)
# Out: 3

begin, *tail = "Hello"
print(begin)
# Out: 'H'
print(tail)
# Out: ['e', 'l', 'l', 'o']

person = ('John', 'Doe', (10, 16, 2016))
*_, (*_, year_of_birth) = person
print(year_of_birth)
# Out: 2016

*head, *tail = [1, 2]
# Out: SyntaxError: two starred expressions in assignment

{*range(4), 4, *(5, 6, 7)}
# Out: {0, 1, 2, 3, 4, 5, 6, 7}

iterable = [1, 2, 3, 4, 5]
print(iterable)
# Out: [1, 2, 3, 4, 5]
print(*iterable)
# Out: 1 2 3 4 5

tail = {'y': 2, 'z': 3}
{'x': 1, **tail}
 # Out: {'x': 1, 'y': 2, 'z': 3}

dict1 = {'x': 1, 'y': 1}
dict2 = {'y': 2, 'z': 3}
{**dict1, **dict2}
# Out: {'x': 1, 'y': 2, 'z': 3}

# Works in Python 2, but syntax error in Python 3:
map(lambda (x, y): x + y, zip(range(5), range(5)))
# Same is true for non-lambdas:
def example((x, y)):
    pass

# Works in both Python 2 and Python 3:
map(lambda x: x[0] + x[1], zip(range(5), range(5)))
# And non-lambdas, too:
def working_example(x_y):
    x, y = x_y
    pass

예외 발생 및 처리

이 쉼표주의, 파이썬이 구문 , 온 raise 및 except 라인 :

try:
    raise IOError, "input/output error"
except IOError, exc:
    print exc

파이썬 3에서 , 구문은 떨어 교체 괄호되고 as 키워드 :

try:
    raise IOError("input/output error")
except IOError as exc:
    print(exc)

이전 버전과의 호환성을 위해 Python 3 구문은 Python 2.6 이상에서도 사용할 수 있으므로 이전 버전과 호환 될 필요가없는 모든 새 코드에 사용해야합니다.

try:
    file = open('database.db')
except FileNotFoundError as e:
    raise DatabaseError('Cannot open {}') from e

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
FileNotFoundError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
DatabaseError('Cannot open database.db')

try:
    file = open('database.db')
except FileNotFoundError as e:
    raise DatabaseError('Cannot open {}')

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
FileNotFoundError

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
DatabaseError('Cannot open database.db')

import sys
import traceback

try:
    funcWithError()
except:
    sys_vers = getattr(sys, 'version_info', (0,))
    if sys_vers < (3, 0):
        traceback.print_exc()
    raise Exception("new exception")

try:
    file = open('database.db')
except FileNotFoundError as e:
    raise DatabaseError('Cannot open {}') from None

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
DatabaseError('Cannot open database.db')

import six
try:
    file = open('database.db')
except FileNotFoundError as e:
    six.raise_from(DatabaseError('Cannot open {}'), None)

이터레이터의 .next () 메소드 이름이 바뀌 었습니다.

Python 2에서는 iterator 자체에서 next 라는 메서드를 사용하여 반복자를 탐색 할 수 있습니다.

g = (i for i in range(0, 3))
g.next()  # Yields 0
g.next()  # Yields 1
g.next()  # Yields 2

파이썬 3에서 .next 메쏘드의 이름은 .__next__ 로 바뀌 .__next__ , "magic"역할을 인정 받았다. 그래서 .next 를 호출하면 AttributeError . Python 2와 Python 3 모두에서이 기능에 액세스하는 올바른 방법은 iterator를 인수로 사용하여 next 함수 를 호출하는 것이다.

g = (i for i in range(0, 3))
next(g)  # Yields 0
next(g)  # Yields 1
next(g)  # Yields 2

이 코드는 2.6에서 현재 릴리스까지의 버전에서 이식 가능합니다.

다른 유형의 비교

[1, 2] > 'foo'
# Out: False
(1, 2) > 'foo'
# Out: True
[1, 2] > (1, 2)
# Out: False
100 < [1, 'x'] < 'xyz' < (1, 'x')
# Out: True

l = [7, 'x', (1, 2), [5, 6], 5, 8.0, 'y', 1.2, [7, 8], 'z']
sorted(l)
# Out: [1.2, 5, 7, 8.0, [5, 6], [7, 8], 'x', 'y', 'z', (1, 2)]

1 < 1.5
# Out: True

[1, 2] > 'foo'
# TypeError: unorderable types: list() > str()
(1, 2) > 'foo'
# TypeError: unorderable types: tuple() > str()
[1, 2] > (1, 2)
# TypeError: unorderable types: list() > tuple()

Python 3에서 혼합 목록을 유형별로 정렬하고 버전 간 호환성을 얻으려면 정렬 된 함수에 키를 제공해야합니다.

>>> list = [1, 'hello', [3, 4], {'python': 2}, 'stackoverflow', 8, {'python': 3}, [5, 6]]
>>> sorted(list, key=str)
# Out: [1, 8, [3, 4], [5, 6], 'hello', 'stackoverflow', {'python': 2}, {'python': 3}]

key 함수로 str 을 사용하면 비교 목적으로 만 각 항목을 일시적으로 문자열로 변환합니다. 그런 다음 [ , ' , { 또는 0-9 시작하는 문자열 표현을 볼 수 있으며 그 문자를 모두 정렬 할 수 있습니다.

사용자 입력

Python 2에서는 raw_input 함수를 사용하여 사용자 입력을 허용하고,

user_input = raw_input()

Python 3에서 사용자 입력은 input 함수를 사용하여 허용됩니다.

user_input = input()

파이썬 2에서는 input 함수가 입력을 받아 들여 해석 합니다. 이 방법이 유용 할 수는 있지만 몇 가지 보안 고려 사항이 있으며 Python 3에서 제거되었습니다. 동일한 기능에 액세스하려면 eval(input()) 사용할 수 있습니다.

두 버전에서 스크립트를 이식성있게 유지하려면 아래 코드를 Python 스크립트 상단 근처에 넣을 수 있습니다.

try:
    input = raw_input
except NameError:
    pass

사전 방법 변경

파이썬 3에서, 많은 사전 메서드는 파이썬 2와는 상당히 다른 동작을하며 많은 것들이 제거되었다 : has_key , iter* , view* 는 없어졌다. 오래 동안 사용되지 않아 왔던 d.has_key(key) 대신 key in d 사용해야합니다.

파이썬 2에서는 사전 메서드 keys , values 및 items 목록을 반환합니다. 파이썬 3에서는 대신 뷰 객체를 반환합니다. 뷰 객체는 반복자가 아니며 다음과 같은 두 가지 측면에서 서로 다릅니다.

• 그들은 크기가 있습니다 (하나는 len 함수를 사용할 수 있습니다)
• 그들은 여러 번 반복 될 수있다.

또한 이터레이터와 마찬가지로 사전의 변경 사항이 뷰 객체에 반영됩니다.

파이썬 2.7은 파이썬 3에서이 메소드를 백 포트했다. viewkeys , viewvalues 및 viewitems 으로 사용할 수 있습니다. 파이썬 2 코드를 파이썬 3 코드로 변환하려면, 다음과 같은 형식이 필요합니다.

• Python 2의 d.keys() , d.values() 및 d.items() 는 list(d.keys()) , list(d.values()) 및 list(d.items())
• d.iterkeys() , d.itervalues() 및 d.iteritems() 는 iter(d.keys()) 또는 iter(d) 로 변경해야합니다. iter(d.values()) 및 iter(d.items()) 각각
• 그리고 마지막으로 파이썬 2.7 방법은 호출 d.viewkeys() , d.viewvalues() 와 d.viewitems() 로 대체 할 수 d.keys() , d.values() 및 d.items() .

사전 키, 값 또는 항목을 돌연변이하는 동안 반복 하는 Python 2 코드를 이식하는 것은 때로는 까다 롭습니다. 중히 여기다:

d = {'a': 0, 'b': 1, 'c': 2, '!': 3}
for key in d.keys():
    if key.isalpha():
        del d[key]

코드는 파이썬 3에서와 유사하게 동작하지만, keys 메소드는리스트가 아닌 뷰 객체를 반환하고 반복되는 동안 사전 크기가 변경되면 Python 3 코드가 RuntimeError: dictionary changed size during iteration 와 충돌합니다 RuntimeError: dictionary changed size during iteration . 해결책은 물론 for key in list(d) 를 적절하게 작성하는 것 for key in list(d) .

마찬가지로, 뷰 객체는 iterator와 다르게 행동합니다. 하나는 next() 를 사용할 수없고 하나는 반복을 재개 할 수 없습니다. 대신에 다시 시작됩니다. 파이썬 2 코드가 d.iterkeys() , d.itervalues() 또는 d.iteritems() 의 반환 값을 iterable 대신 iterator를 요구하는 메소드에 전달하면 iter(d) , iter(d.values()) Python 3에서는 iter(d.values()) 또는 iter(d.items()) 를 사용합니다.

exec 문은 Python 3의 함수입니다.

파이썬 2에서, exec 는 특별한 문법을 ​​가진 명령문입니다 : exec code [in globals[, locals]]. 파이썬 3에서 exec 는 이제 함수 : exec(code, [, globals[, locals]]) 가되고 Python 2 구문은 SyntaxError 시킵니다.

print 가 statement에서 function으로 변경됨에 따라 __future__ import가 추가되었습니다. 그러나 from __future__ import exec_function 은 필요하지 않으므로 no가 from __future__ import exec_function . 파이썬 2의 exec 문은 파이썬 3에서 exec 함수 호출과 똑같은 구문으로도 사용될 수 있습니다. 따라서 명령문을 변경할 수 있습니다

exec 'code'
exec 'code' in global_vars
exec 'code' in global_vars, local_vars

형태에

exec('code')
exec('code', global_vars)
exec('code', global_vars, local_vars)

후자의 형식은 Python 2와 Python 3 모두에서 동일하게 작동합니다.

파이썬 2에서 hasattr 함수 버그

파이썬 2에서, 프로퍼티가 에러를 발생 hasattr , hasattr 은이 프로퍼티를 무시하고 False 리턴합니다.

class A(object):
    @property
    def get(self):
        raise IOError


class B(object):
    @property
    def get(self):
        return 'get in b'

a = A()
b = B()

print 'a hasattr get: ', hasattr(a, 'get')
# output False in Python 2 (fixed, True in Python 3)
print 'b hasattr get', hasattr(b, 'get')
# output True in Python 2 and Python 3

이 버그는 Python3에서 수정되었습니다. 따라서 파이썬 2를 사용한다면

try:
    a.get
except AttributeError:
    print("no get property!")

대신 getattr 사용하십시오.

p = getattr(a, "get", None)
if p is not None:
    print(p)
else:
    print("no get property!")

모듈 이름이 변경됨

표준 라이브러리의 몇 가지 모듈 이름이 바뀌 었습니다.

일부 모듈은 심지어 파일에서 라이브러리로 변환되었습니다. 위의 tkinter 및 urllib를 예로 들어 보겠습니다.

적합성

Python 2.x 및 3.x 버전 간의 호환성을 유지할 때 future 외부 패키지 를 사용하여 Python 2.x 버전에서 Python 3.x 이름을 사용하여 최상위 표준 라이브러리 패키지를 가져올 수 있습니다.

8 진 상수

파이썬 2에서는 8 진수를 다음과 같이 정의 할 수 있습니다.

>>> 0755  # only Python 2

상호 호환성을 보장하려면

0o755  # both Python 2 and Python 3

모든 클래스는 파이썬 3에서 "새로운 스타일의 클래스"입니다.

Python 3.x 모든 클래스는 새로운 스타일의 클래스입니다 . 새로운 클래스를 정의 할 때 파이썬은 암시 적으로 object 로부터 상속받습니다. 따라서 class 정의에서 object 를 지정하는 것은 완전히 선택 사항입니다.

class X: pass
class Y(object): pass

이 두 클래스는 모두 mro (메서드 확인 순서)에 object 를 포함 object .

>>> X.__mro__
(__main__.X, object)

>>> Y.__mro__
(__main__.Y, object)

Python 2.x 클래스는 기본적으로 구식 클래스입니다. 암묵적으로 object 상속받지 않습니다. 이것은 우리가 명시 적으로 object 를 기본 class 로 추가하는지에 따라 클래스의 의미를 다르게 object :

class X: pass
class Y(object): pass

이 경우 Y 의 __mro__ 을 인쇄하려고하면 Python 3.x 경우와 비슷한 출력이 나타납니다.

>>> Y.__mro__
(<class '__main__.Y'>, <type 'object'>)

이것은 우리가 명시 적으로 Y 를 객체를 정의 할 때 상속했기 때문에 발생합니다 : class Y(object): pass . 객체에서 상속받지 않는 클래스 X 경우 __mro__ 속성이 존재하지 않으므로 액세스하려고하면 AttributeError 합니다.

두 버전의 Python 사이의 호환성 을 보장 하기 위해 object 를 기본 클래스로 정의 할 수 있습니다.

class mycls(object):
    """I am fully compatible with Python 2/3"""

또는 __metaclass__ 변수가 전역 범위에서 type 하도록 설정된 경우 지정된 모듈의 이후에 정의되는 모든 클래스는 명시 적으로 object 에서 상속하지 않아도 암시 적으로 새 스타일입니다.

__metaclass__ = type

class mycls:
    """I am also fully compatible with Python 2/3"""

제거 된 연산자 <> 및!`,! = 및 repr ()과 동의어

Python 2에서 <> 는 != ;와 동의어입니다. 마찬가지로 `foo` 는 repr(foo) 의 동의어입니다.

>>> 1 <> 2
True
>>> 1 <> 1
False
>>> foo = 'hello world'
>>> repr(foo)
"'hello world'"
>>> `foo`
"'hello world'"

>>> 1 <> 2
  File "<stdin>", line 1
    1 <> 2
       ^
SyntaxError: invalid syntax
>>> `foo`
  File "<stdin>", line 1
    `foo`
    ^
SyntaxError: invalid syntax

더 이상 사용할 수없는 16 진수로 인코딩 / 디코딩

"1deadbeef3".decode('hex')
# Out: '\x1d\xea\xdb\xee\xf3'
'\x1d\xea\xdb\xee\xf3'.encode('hex')
# Out: 1deadbeef3

"1deadbeef3".decode('hex')
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# AttributeError: 'str' object has no attribute 'decode'

b"1deadbeef3".decode('hex')
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# LookupError: 'hex' is not a text encoding; use codecs.decode() to handle arbitrary codecs

'\x1d\xea\xdb\xee\xf3'.encode('hex')
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# LookupError: 'hex' is not a text encoding; use codecs.encode() to handle arbitrary codecs

b'\x1d\xea\xdb\xee\xf3'.encode('hex')
# Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
# AttributeError: 'bytes' object has no attribute 'encode'

그러나 오류 메시지에서 제안한 것처럼 codecs 모듈을 사용하여 동일한 결과를 얻을 수 있습니다.

import codecs
codecs.decode('1deadbeef4', 'hex')
# Out: b'\x1d\xea\xdb\xee\xf4'
codecs.encode(b'\x1d\xea\xdb\xee\xf4', 'hex')
# Out: b'1deadbeef4'

codecs.encode 는 bytes 객체를 반환합니다. str 객체를 얻기 위해서는 단지 ASCII로 decode 해야합니다 :

codecs.encode(b'\x1d\xea\xdb\xee\xff', 'hex').decode('ascii')
# Out: '1deadbeeff'

Python 3에서 cmp 함수가 제거되었습니다.

Python 3에서는 cmp 내장 함수가 __cmp__ 특수 메서드와 함께 제거되었습니다.

문서에서 :

cmp() 함수는 __cmp__() 처리되어야하며 __cmp__() 특수 메서드는 더 이상 지원되지 않습니다. 정렬에는 __lt__() , __eq__() 와 __hash__() 및 기타 다양한 비교가 필요할 때 사용하십시오. (당신이 정말로 필요한 경우 cmp() 기능을, 당신은 표현을 사용할 수있다 (a > b) - (a < b) 에 해당하는 등의 cmp(a, b) .)

게다가 cmp 매개 변수를 cmp 모든 내장 함수는 key 키워드 전용 매개 변수만을 허용합니다.

functools 모듈에는 cmp cmp_to_key(func) 함수에서 key 스타일 함수로 변환 할 수있는 유용한 함수 cmp_to_key(func) 가 있습니다.

이전 스타일의 비교 함수를 키 함수로 변환합니다. 주요 기능 ( sorted() , min() , max() , heapq.nlargest() , heapq.nsmallest() , itertools.groupby() )을 허용하는 도구와 함께 사용됩니다. 이 함수는 주로 비교 함수 사용을 지원하는 Python 2에서 변환되는 프로그램의 전환 도구로 사용됩니다.

목록 이해에 누출 된 변수

x = 'hello world!'
vowels = [x for x in 'AEIOU'] 

print (vowels)
# Out: ['A', 'E', 'I', 'O', 'U']
print(x)
# Out: 'U'   

x = 'hello world!'
vowels = [x for x in 'AEIOU']

print (vowels)
# Out: ['A', 'E', 'I', 'O', 'U']
print(x)
# Out: 'hello world!'

이 예제에서 볼 수 있듯이 Python 2에서는 x 값이 누수되었습니다. hello world! 마스크했습니다 hello world! 루프가 끝났을 때 이것이 x 의 마지막 값 이었기 때문에 U 출력했다.

그러나 Python 3 x 에서는 원래 정의 된 hello world! 인쇄합니다 hello world! 왜냐하면 list comprehension의 지역 변수는 주변 범위의 변수를 숨기지 않기 때문입니다.

또한 생성기 표현식 (파이썬 2.5에서 사용 가능)이나 사전 또는 집합 내포 (파이썬 3에서 파이썬 2.7로 백 포트 된)는 파이썬 2에서 변수를 누출하지 않습니다.

파이썬 2와 파이썬 3 모두에서 for 루프를 사용할 때 변수는 주변 범위로 누출됩니다.

x = 'hello world!'
vowels = []
for x in 'AEIOU':
    vowels.append(x)
print(x)
# Out: 'U'

지도()

map() 은 반복 가능한 요소에 함수를 적용하는 데 유용한 내장 함수입니다. 파이썬 2에서 map 은리스트를 반환합니다. Python 3에서 map 은 생성자 인 map 객체를 반환합니다.

# Python 2.X
>>> map(str, [1, 2, 3, 4, 5])
['1', '2', '3', '4', '5']
>>> type(_)
>>> <class 'list'>

# Python 3.X
>>> map(str, [1, 2, 3, 4, 5])
<map object at 0x*>
>>> type(_)
<class 'map'>

# We need to apply map again because we "consumed" the previous map....
>>> map(str, [1, 2, 3, 4, 5])
>>> list(_)
['1', '2', '3', '4', '5']

Python 2에서는 None 을 전달하여 ID 함수로 사용할 수 있습니다. 이것은 더 이상 파이썬 3에서 작동하지 않습니다.

>>> map(None, [0, 1, 2, 3, 0, 4])
[0, 1, 2, 3, 0, 4]

>>> list(map(None, [0, 1, 2, 3, 0, 5]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not callable

게다가 파이썬 2에서 하나 이상의 iterable을 인수로 전달할 때 map 은 더 짧은 iterable을 None 으로 채 itertools.izip_longest ( itertools.izip_longest 와 유사). Python 3에서는 가장 짧은 iterable 후에 반복이 멈 춥니 다.

파이썬 2에서 :

>>> map(None, [1, 2, 3], [1, 2], [1, 2, 3, 4, 5])
[(1, 1, 1), (2, 2, 2), (3, None, 3), (None, None, 4), (None, None, 5)]

파이썬 3 :

>>> list(map(lambda x, y, z: (x, y, z), [1, 2, 3], [1, 2], [1, 2, 3, 4, 5]))
[(1, 1, 1), (2, 2, 2)]

# to obtain the same padding as in Python 2 use zip_longest from itertools
>>> import itertools
>>> list(itertools.zip_longest([1, 2, 3], [1, 2], [1, 2, 3, 4, 5]))
[(1, 1, 1), (2, 2, 2), (3, None, 3), (None, None, 4), (None, None, 5)]

참고 : map 대신에 파이썬 2/3과 호환되는리스트 보 완성을 사용하는 것을 고려하십시오. map(str, [1, 2, 3, 4, 5]) 바꾸기 map(str, [1, 2, 3, 4, 5]) :

>>> [str(i) for i in [1, 2, 3, 4, 5]]
['1', '2', '3', '4', '5']

filter (), map () 및 zip ()은 시퀀스 대신 반복자를 반환합니다.

>>> s = filter(lambda x: x.isalpha(), 'a1b2c3')
>>> s
'abc'
>>> s = map(lambda x: x * x, [0, 1, 2])
>>> s
[0, 1, 4]
>>> s = zip([0, 1, 2], [3, 4, 5])
>>> s
[(0, 3), (1, 4), (2, 5)]

>>> it = filter(lambda x: x.isalpha(), 'a1b2c3')
>>> it
<filter object at 0x00000098A55C2518>
>>> ''.join(it)
'abc'
>>> it = map(lambda x: x * x, [0, 1, 2])
>>> it
<map object at 0x000000E0763C2D30>
>>> list(it)
[0, 1, 4]
>>> it = zip([0, 1, 2], [3, 4, 5])
>>> it
<zip object at 0x000000E0763C52C8>
>>> list(it)
[(0, 3), (1, 4), (2, 5)]

Python 2부터 itertools.izip 은 Python 3과 동일합니다. zip izip 은 Python 3에서 제거되었습니다.

절대 / 상대 수입

Python 3에서 PEP 404 는 수입이 Python 2에서 작동하는 방식을 변경합니다. 암시 적 상대 수입은 더 이상 패키지 from ... import * 허용되지 않습니다 from ... import * 는 모듈 수준 코드에서만 허용됩니다.

파이썬 2에서 파이썬 3 동작을 얻으려면 :

• 절대 import 기능은 from __future__ import absolute_import 활성화 할 수 있습니다. from __future__ import absolute_import
• 명시 적 상대적인 수입은 암묵적 상대 수입 대신에 권장된다.

설명을 위해 Python 2에서 모듈은 다음과 같은 디렉토리에있는 다른 모듈의 내용을 가져올 수 있습니다.

import foo

foo 의 위치는 import 문만으로는 모호합니다. 따라서 이러한 유형의 암시 적 상대 가져 오기는 다음과 같이 명시 적 상대 가져 오기를 사용하지 않는 것이 좋습니다.

from .moduleY import spam
from .moduleY import spam as ham
from . import moduleY
from ..subpackage1 import moduleY
from ..subpackage2.moduleZ import eggs
from ..moduleA import foo
from ...package import bar
from ...sys import path

점 . 디렉토리 트리 내에서 모듈 위치를 명시 적으로 선언 할 수 있습니다.

상대적 수입에 대한 추가 정보

shapes 이라는 사용자 정의 패키지를 고려하십시오. 디렉토리 구조는 다음과 같습니다.

shapes
├── __init__.py
|
├── circle.py
|
├── square.py
|
└── triangle.py

circle.py , square.py 및 triangle.py 모두 모듈로 util.py 를 가져옵니다. 동일한 수준의 모듈을 어떻게 참조 할 것입니까?

 from . import util # use util.PI, util.sq(x), etc

또는

 from .util import * #use PI, sq(x), etc to call functions

그 . 동일한 레벨의 상대적 가져 오기에 사용됩니다.

이제 shapes 모듈의 대체 레이아웃을 고려하십시오.

shapes
├── __init__.py
|
├── circle
│   ├── __init__.py
│   └── circle.py
|
├── square
│   ├── __init__.py
│   └── square.py
|
├── triangle
│   ├── __init__.py
│   ├── triangle.py
|
└── util.py

이제이 3 개의 클래스는 util.py를 어떻게 참조할까요?

 from .. import util # use util.PI, util.sq(x), etc

또는

 from ..util import * # use PI, sq(x), etc to call functions

.. 는 부모 수준의 상대적 가져 오기에 사용됩니다. 더 추가하십시오 . 부모와 자식 사이의 레벨 수를 비교합니다.

파일 I / O

file 은 더 이상 3.x에서 기본 제공 이름이 아닙니다 ( open 그대로).

파일 I / O의 내부 세부 사항이 표준 라이브러리 io 모듈로 옮겨졌습니다.이 모듈은 또한 StringIO 의 새로운 홈입니다.

import io
assert io.open is open # the builtin is an alias
buffer = io.StringIO()
buffer.write('hello, ') # returns number of characters written
buffer.write('world!\n')
buffer.getvalue() # 'hello, world!\n'

파일 모드 (텍스트 대 바이너리)는 이제 파일을 읽음으로써 생성되는 데이터의 유형을 결정합니다 (그리고 쓰기 위해 필요한 유형).

with open('data.txt') as f:
    first_line = next(f)
    assert type(first_line) is str
with open('data.bin', 'rb') as f:
    first_kb = f.read(1024)
    assert type(first_kb) is bytes

텍스트 파일의 인코딩은 기본적으로 locale.getpreferredencoding(False) 의해 반환되는 locale.getpreferredencoding(False) 인코딩됩니다. 인코딩을 명시 적으로 지정하려면 encoding 키워드 매개 변수를 사용하십시오.

with open('old_japanese_poetry.txt', 'shift_jis') as text:
    haiku = text.read()

round () 함수 타이 브레이킹과 리턴 타입

둥근 () 타이 브레이킹

파이썬 2에서는 2 개의 정수에 동등하게 가까운 숫자에 round() 를 사용하면 0에서 가장 먼 것을 반환합니다. 예를 들면 다음과 같습니다.

round(1.5)  # Out: 2.0
round(0.5)  # Out: 1.0
round(-0.5)  # Out: -1.0
round(-1.5)  # Out: -2.0

그러나 파이썬 3에서 round() 는 짝수 정수를 반환합니다 ( 은행원의 반올림 ). 예 :

round(1.5)  # Out: 2
round(0.5)  # Out: 0
round(-0.5)  # Out: 0
round(-1.5)  # Out: -2

round () 함수는 절반 짝수 를 가장 가까운 짝수 정수로 반올림하는 반올림 전략의 절반을 따릅니다 (예 : round(2.5) 가 3.0이 아닌 2를 반환).

Wikipedia의 참고 자료에 따르면, 이것은 바이어스되지 않은 반올림 , 수렴형 반올림 , 통계학 자의 반올림 , 네덜란드 반올림 , 가우시안 반올림 또는 홀수 짝수 반올림 이라고도합니다.

반올림에서 반올림은 IEEE 754 표준의 일부이며 Microsoft .NET의 기본 반올림 모드이기도합니다.

이 라운딩 전략은 전체 반올림 오류를 줄이는 경향이 있습니다. 평균적으로 반올림되는 숫자의 양은 반올림 된 숫자의 양과 동일하므로 반올림 오류가 취소됩니다. 대신 다른 반올림 방법은 평균 오차에 상향 또는 하향 편향을하는 경향이 있습니다.

round () 반환 형식

round() 함수는 Python 2.7에서 float 유형을 반환합니다.

round(4.8)
# 5.0

파이썬 3.0에서 시작하여 두 번째 인수 (자릿수)가 생략되면 int 반환합니다.

round(4.8)
# 5

참, 거짓 및 없음

Python 2에서 True , False 및 None 은 기본 제공 상수입니다. 즉, 재 할당이 가능하다는 의미입니다.

True, False = False, True
True   # False
False  # True

Python 2.4부터는 None 해서는 안된다.

None = None  # SyntaxError: cannot assign to None

Python 3에서는 True , False 및 None 이 키워드가되었습니다.

True, False = False, True  # SyntaxError: can't assign to keyword

None = None  # SyntaxError: can't assign to keyword

파일 객체에 쓸 때의 반환 값

파이썬 2에서 파일 핸들에 직접 쓰는 것은 None 반환합니다 :

hi = sys.stdout.write('hello world\n')
# Out: hello world
type(hi)
# Out: <type 'NoneType'>

파이썬 3에서, 핸들에 쓰는 것은 텍스트를 쓸 때 쓰는 문자의 수와 바이트를 쓸 때 쓰는 바이트의 수를 반환합니다 :

import sys

char_count = sys.stdout.write('hello world 🐍\n')
# Out: hello world 🐍
char_count
# Out: 14

byte_count = sys.stdout.buffer.write(b'hello world \xf0\x9f\x90\x8d\n')
# Out: hello world 🐍
byte_count
# Out: 17

long과 int 비교

Python 2에서 C ssize_t 보다 큰 정수는 리터럴에 L 접미사로 표시된 long 데이터 유형으로 변환됩니다. 예를 들어, 32 비트 빌드의 Python :

>>> 2**31
2147483648L
>>> type(2**31)
<type 'long'>
>>> 2**30
1073741824
>>> type(2**30)
<type 'int'>
>>> 2**31 - 1  # 2**31 is long and long - int is long
2147483647L

그러나 Python 3에서는 long 데이터 형식이 제거되었습니다. 정수가 아무리 크면 int 됩니다.

2**1024
# Output: 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
print(-(2**1024))
# Output: -179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
type(2**1024)
# Output: <class 'int'>

클래스 부울 값

class MyClass:
    def __nonzero__(self):
        return False

my_instance = MyClass()
print bool(MyClass)       # True
print bool(my_instance)   # False

class MyClass:
    def __bool__(self):
        return False

my_instance = MyClass()
print(bool(MyClass))       # True
print(bool(my_instance))   # False