Отличие python метода методы - В чем разница между функцией, несвязанным методом и связанным методом? Пример: брюки превращаются. Целые числа и числа с плавающей запятой
Мы немного поговорили, теперь поговорим о функциях и методах строк .
Я постарался собрать здесь все строковые методы и функции, но если я что-то забыл - поправляйте.
Базовые операции
Дублирование строки
>>> print ("spam" * 3 ) spamspamspamДлина строки (функция len)
>>> len ("spam" ) 4Доступ по индексу
>>> S = "spam" >>> S [ 0 ] "s" >>> S [ 2 ] "a" >>> S [ - 2 ] "a"Как видно из примера, в Python возможен и доступ по отрицательному индексу, при этом отсчет идет от конца строки.
Извлечение среза
Оператор извлечения среза: . X – начало среза, а Y – окончание;
символ с номером Y в срез не входит. По умолчанию первый индекс равен 0, а второй - длине строки.
>>> s = "spameggs" >>> s [ 3 : 5 ] "me" >>> s [ 2 : - 2 ] "ameg" >>> s [: 6 ] "spameg" >>> s [ 1 :] "pameggs" >>> s [:] "spameggs"Кроме того, можно задать шаг, с которым нужно извлекать срез.
>>> s [:: - 1 ] "sggemaps" >>> s [ 3 : 5 : - 1 ] "" >>> s [ 2 :: 2 ] "aeg"
Конкатенация (сложение)
>>> S1 = "spam" >>> S2 = "eggs" >>> print (S1 + S2 ) "spameggs"Другие функции и методы строк
При вызове методов необходимо помнить, что строки в Python относятся к категории неизменяемых последовательностей, то есть все функции и методы могут лишь создавать новую строку.
>>> s = "spam" >>> s [ 1 ] = "b" Traceback (most recent call last): File "", line 1, in s = "b" TypeError : "str" object does not support item assignment >>> s = s [ 0 ] + "b" + s [ 2 :] >>> s "sbam"Поэтому все строковые методы возвращают новую строку, которую потом следует присвоить переменной.
Таблица "Функции и методы строк"
| Функция или метод | Назначение |
|---|---|
| S = "str"; S = "str"; S = """str"""; S = """str""" | |
| S = "s\np\ta\nbbb" | Экранированные последовательности |
| S = r"C:\temp\new" | Неформатированные строки (подавляют экранирование) |
| S = b"byte" | Строка |
| S1 + S2 | Конкатенация (сложение строк) |
| S1 * 3 | Повторение строки |
| S[i] | Обращение по индексу |
| S | Извлечение среза |
| len (S) | Длина строки |
| S.find (str, ,) | Поиск подстроки в строке. Возвращает номер первого вхождения или -1 |
| S.rfind (str, ,) | Поиск подстроки в строке. Возвращает номер последнего вхождения или -1 |
| S.index (str, ,) | Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError |
| S.rindex (str, ,) | Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError |
| S.replace (шаблон, замена) | Замена шаблона |
| S.split (символ) | Разбиение строки по разделителю |
| S.isdigit () | Состоит ли строка из цифр |
| S.isalpha () | Состоит ли строка из букв |
| S.isalnum () | Состоит ли строка из цифр или букв |
| S.islower () | Состоит ли строка из символов в нижнем регистре |
| S.isupper () | Состоит ли строка из символов в верхнем регистре |
| S.isspace () | Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы ("\f"), "новая строка" ("\n"), "перевод каретки" ("\r"), "горизонтальная табуляция" ("\t") и "вертикальная табуляция" ("\v")) |
| S.istitle () | Начинаются ли слова в строке с заглавной буквы |
| S.upper () | Преобразование строки к верхнему регистру |
| S.lower () | Преобразование строки к нижнему регистру |
| S.startswith (str) | Начинается ли строка S с шаблона str |
| S.endswith (str) | Заканчивается ли строка S шаблоном str |
| S.join (список) | Сборка строки из списка с разделителем S |
| ord (символ) | Символ в его код ASCII |
| chr (число) | Код ASCII в символ |
| S.capitalize () | Переводит первый символ строки в верхний регистр, а все остальные в нижний |
| S.center (width, ) | Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию) |
| S.count (str, ,) | Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию) |
| S.expandtabs () | Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам |
| S.lstrip () | Удаление пробельных символов в начале строки |
| S.rstrip () | Удаление пробельных символов в конце строки |
| S.strip () | Удаление пробельных символов в начале и в конце строки |
| S.partition (шаблон) | Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки |
| S.rpartition (sep) | Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку |
| S.swapcase () | Переводит символы нижнего регистра в верхний, а верхнего – в нижний |
| S.title () | Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний |
| S.zfill (width) | Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями |
| S.ljust (width, fillchar=" ") | Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar |
| S.rjust (width, fillchar=" ") | Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar |
| S.format (*args, **kwargs) |
| Оператор | Описание | Примеры |
|---|---|---|
| + | Сложение - Суммирует значения слева и справа от оператора |
15 + 5 в результате будет 20 |
| - | Вычитание - Вычитает правый операнд из левого | 15 - 5 в результате будет 10 20 - -3 в результате будет 23 13.4 - 7 в результате будет 6.4 |
| * | Умножение - Перемножает операнды | 5 * 5 в результате будет 25 7 * 3.2 в результате будет 22.4 -3 * 12 в результате будет -36 |
| / | Деление - Делит левый операнд на правый | 15 / 5 в результате будет 3 5 / 2 в результате будет 2 (В Python 2.x версии при делении двух целых чисел результат будет целое число) 5.0 / 2 в результате будет 2.5 (Чтобы получить "правильный" результат хотя бы один операнд должен быть float) |
| % | Деление по модулю - Делит левый операнд на правый и возвращает остаток. | 6 % 2 в результате будет 0 7 % 2 в результате будет 1 13.2 % 5 в результате 3.2 |
| ** | Возведение в степень - возводит левый операнд в степень правого | 5 ** 2 в результате будет 25 2 ** 3 в результате будет 8 -3 ** 2 в результате будет -9 |
| // | Целочисленное деление - Деление в котором возвращается только целая часть результата. Часть после запятой отбрасывается. | 12 // 5 в результате будет 2 4 // 3 в результате будет 1 25 // 6 в результате будет 4 |
Операторы сравнения в Python:
| Оператор | Описание | Примеры |
|---|---|---|
| == | Проверяет равны ли оба операнда. Если да, то условие становится истинным. | 5 == 5 в результате будет True True == False в результате будет False "hello" == "hello" в результате будет True |
| != | 12 != 5 в результате будет True False != False в результате будет False "hi" != "Hi" в результате будет True |
|
| <> | Проверяет равны ли оба операнда. Если нет, то условие становится истинным. |
12 <> 5 в результате будет True. Похоже на оператор!= |
| > | Проверяет больше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 5 > 2 в результате будет True. True > False в результате будет True. "A" > "B" в результате будет False. |
| < | Проверяет меньше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 3 < 5 в результате будет True. True < False в результате будет False. "A" < "B" в результате будет True. |
| >= | Проверяет больше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 1 >= 1 в результате будет True. 23 >= 3.2 в результате будет True. "C" >= "D" в результате будет False. |
| <= | Проверяет меньше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. -0.001 <= -36 в результате будет False. |
Операторы присваивания в Python:
| Оператор | Описание | Примеры |
|---|---|---|
| = | Присваивает значение правого операнда левому. | c = 23 присвоит переменной с значение 23 |
| += | Прибавит значение правого операнда к левому и присвоит эту сумму левому операнду. |
с = 5 |
| -= | Отнимает значение правого операнда от левого и присваивает результат левому операнду. |
с = 5 |
| *= | Умножает правый операнд с левым и присваивает результат левому операнду. |
с = 5 |
| /= | Делит левый операнд на правый и присваивает результат левому операнду. | с = 10 а = 2 с /= а равносильно: с = с / а. c будет равно 5 |
| %= | Делит по модулю операнды и присваивает результат левому. | с = 5 а = 2 с %= а равносильно: с = с % а. c будет равно 1 |
| **= | Возводит в левый операнд в степень правого и присваивает результат левому операнду. | с = 3 а = 2 с **= а равносильно: с = с ** а. c будет равно 9 |
| //= | Производит целочисленное деление левого операнда на правый и присваивает результат левому операнду. | с = 11 а = 2 с //= а равносильно: с = с // а. c будет равно 5 |
Побитовые операторы в Python:
Побитовые операторы предназначены для работы с данными в битовом (двоичном) формате. Предположим, что у нас есть два числа a = 60; и b = 13. В двоичном формате они будут иметь следующий вид:
| Оператор | Описание | Примеры |
|---|---|---|
| & | Бинарный "И" оператор, копирует бит в результат только если бит присутствует в обоих операндах. | (a & b) даст нам 12, которое в двоичном формате выглядит так 0000 1100 |
| | | Бинарный "ИЛИ" оператор копирует бит, если тот присутствует в хотя бы в одном операнде. | (a | b) даст нам 61, в двоичном формате 0011 1101 |
| ^ | Бинарный "Исключительное ИЛИ" оператор копирует бит только если бит присутствует в одном из операндов, но не в обоих сразу. | (a ^ b) даст нам 49, в двоичном формате 0011 0001 |
| ~ | Бинарный комплиментарный оператор. Является унарным (то есть ему нужен только один операнд) меняет биты на обратные, там где была единица становиться ноль и наоборот. | (~a) даст в результате -61, в двоичном формате выглядит 1100 0011. |
| << | Побитовый сдвиг влево. Значение левого операнда "сдвигается" влево на количество бит указанных в правом операнде. | a << 2 в результате даст 240, в двоичном формате 1111 0000 |
| >> | Побитовый сдвиг вправо. Значение левого операнда "сдвигается" вправо на количество бит указанных в правом операнде. | a >> 2 даст 15, в двоичном формате 0000 1111 |
Логические операторы в Python:
| Оператор | Описание | Примеры |
|---|---|---|
| and | Логический оператор "И". Условие будет истинным если оба операнда истина. |
True and True равно True. |
| or | Логический оператор "ИЛИ". Если хотя бы один из операндов истинный, то и все выражение будет истинным. | True or True равно True. True or False равно True. False or True равно True. False or False равно False. |
| not | Логический оператор "НЕ". Изменяет логическое значение операнда на противоположное. | not True равно False. not False равно True. |
Операторы членства в Python:
В добавок к перечисленным операторам, в Python присутствуют, так называмые, операторы членства, предназначенные для проверки на наличие элемента в составных типах данных, таких, как строки, списки, кортежи или словари :
Операторы тождественности в Python:
Операторы тождественности сравнивают размещение двух объектов в памяти компьютера.
Приоритет операторов в Python
В следующей таблице описан приоритет выполнения операторов в Python от наивысшего (выполняется в первую очередь) до наинизшего.
| Оператор | Описание |
|---|---|
| ** | Возведение в степень |
| ~ + - | Комплиментарный оператор |
| * / % // | Умножение, деление, деление по модулю, целочисленное деление. |
| + - | Сложение и вычитание. |
| >> << | Побитовый сдвиг вправо и побитовый сдвиг влево. |
| & | Бинарный "И". |
| ^ | | Бинарный "Исключительное ИЛИ" и бинарный "ИЛИ" |
| <= < > >= | Операторы сравнения |
| <> == != | Операторы равенства |
| = %= /= //= -= += *= **= | Операторы присваивания |
| is is not | Тождественные операторы |
| in not in | Операторы членства |
| not or and | Логические операторы |
Одна интересная вещь, которую я видел сегодня, это то, что когда я назначаю функцию члену класса, она становится несвязанным методом. Такие как:
Class Test(object): @classmethod def initialize_class(cls): def print_string(self, str): print(str) # Here if I do print(print_string), I see a function cls.print_proc = print_string # Here if I do print(cls.print_proc), I see an unbound method; so if I # get a Test object o, I can call o.print_proc("Hello")
2018-12-04T00:00Z
довольно сложно понять
Ну, это довольно сложная тема, и она связана с дескрипторами.
Давайте начнем с функции. Здесь все ясно - вы просто называете это, все предоставленные аргументы передаются при его выполнении:
>>> f = A.__dict__["f1"] >>> f(1) 1
Регулярный TypeError возникает в случае возникновения проблем с количеством параметров:
>>>
Теперь методы. Методы - это функции с небольшим количеством специй. Здесь есть дескрипторы. Как описано в модели данных , A.f1 и A().f1 переводятся в A.__dict__["f1"].__get__(None, A) и type(a).__dict__["f1"].__get__(a, type(a)) соответственно. И результаты этих __get__ отличаются от функции raw f1 . Эти объекты являются обертками вокруг исходного f1 и содержат некоторую дополнительную логику.
В случае unbound method эта логика включает проверку того, является ли первый аргумент экземпляром A:
>>> f = A.f1
>>> f()
Traceback (most recent call last):
File "
Если эта проверка завершается успешно, она выполняет оригинальный f1 с этим экземпляром в качестве первого аргумента:
>>> f(A()) <__main__.A object at 0x800f238d0>
Обратите внимание, что атрибут im_self равен None:
>>> f.im_self is None True
В случае bound method эта логика немедленно поставляет исходный f1 с экземпляром A который был создан (этот экземпляр фактически хранится в im_self):
>>> f = A().f1 >>> f.im_self <__main__.A object at 0x800f23950> >>> f() <__main__.A object at 0x800f23950>
Таким образом, bound означает, что базовая функция привязана к некоторому экземпляру. unbound означает, что он все еще связан, но только с классом.
2018-12-11T00:00Z
Моя интерпретация такова.
Фрагменты Function класса:
Class Function(object): . . . def __get__(self, obj, objtype=None): "Simulate func_descr_get() in Objects/funcobject.c" if obj is None: return self return types.MethodType(self, obj)
Class Function(object): . . . def __get__(self, obj, objtype=None): "Simulate func_descr_get() in Objects/funcobject.c" return types.MethodType(self, obj, objtype)
- Если функция вызывается без класса или экземпляра, это простая функция.
Если функция вызывается из класса или экземпляра, ее __get__ вызывается для извлечения завернутой функции:
а. Bx совпадает с B.__dict__["x"].__get__(None, B) . В Python 3 это возвращает обычную функцию. В Python 2 это возвращает несвязанную функцию.
б. bx аналогичен type(b).__dict__["x"].__get__(b, type(b) . Это вернет связанный метод как в Python 2, так и в Python 3, что означает, что self будет неявно передан в качестве первого аргумента.
Обзор различий синтаксиса python2 и python3.
Print - функция
Оператор print был заменён функцией print(), с именованными аргументами для замены большей части синтаксиса старого оператора print. Примеры:
Python2 : print "The answer is" , 2 * 2 Python3 : print ("The answer is" , 2 * 2 ) Python2 : print x , # Запятая в конце подавляет перевод строки Python3 : print (x , end = " " ) # Добавляет пробел вместо перевода строки Python2 : print # Печатает перевод строки Python3 : print () # Нужно вызвать функцию! Python2 : print >> sys . stderr , "fatal error" Python3 : print ("fatal error" , file = sys . stderr ) Python2 : print (x , y ) # Печатает repr((x, y)) Python3 : print ((x , y )) # Не путать с print(x, y)!Также вы можете настроить разделитель между элементами, например:
>>> print ("There are <" , 2 ** 32 , "> possibilities!" , sep = "" ) There are <4294967296> possibilities!Функция print() не поддерживает особенность "программный пробел" старого оператора print. Например, в Python 2, print "A\n", "B" напечатает "A\nB\n"; но в Python 3, print("A\n", "B") напечатает "A\n B\n".
Отображения и итераторы вместо списков
Некоторые хорошо известные методы не возвращают в Python 3:
- Методы словарей dict.keys(), dict.items() и dict.values() возвращают "отображения" вместо списков. Например, больше не работает: k = d.keys(); k.sort(). Используйте k = sorted(d).
- Соответственно, методы dict.iterkeys(), dict.iteritems() и dict.itervalues() более не поддерживаются.
- map() и filter() возвращают итераторы. Если вам действительно нужен список, быстрым исправлением станет list(map(...)), но часто лучшим исправлением будет использование генераторов списков (особенно когда оригинальный код использует лямбда-выражения), либо переписать код так, чтобы ему не нужен был список как таковой. Особенно сложно, что map() вызывает побочные эффекты функции; правильное преобразование заключается в использовании цикла (создание списка просто расточительно).
- range() теперь ведёт себя как xrange(), но работает со значениями любого размера. xrange() больше не существует.
- zip() возвращает итератор.
Операторы сравнения
Python 3 упростил правила для операторов сравнения:
Операторы сравнения (<, <=, >=, >) поднимают исключение TypeError, когда операнды не упорядочиваемы. Таким образом, выражения типа 1 < "", 0 > None или len <= len более не разрешены, и, например, None < None поднимает TypeError, а не возвращает False. Следствием является то, что сортировка списка с разными типами данных больше не имеет смысла - все элементы должны быть сравнимы друг с другом. Обратите внимание, что это не относится к операторам == и!=: объекты различных несравнимых типов всегда неравны друг другу.
builtin.sorted() и list.sort() больше не принимают аргумент cmp, обеспечивающий функцию сравнения. Вместо этого используйте аргумент key. Аргументы key и reverse теперь "keyword-only".
Функция cmp() должна рассматриваться как устаревшая, и специальный метод __cmp__() в Python 3 не поддерживается. Используйте __lt__() для сортировки, __eq__() с __hash__() для сравнения. (Если вам действительно нужна функциональность cmp(), вы можете использовать выражение (a > b) - (a < b) в качестве эквивалента для cmp(a, b).)
Целые числа
- PEP 0237: long переименован в int.
- PEP 0238: Выражение вида 1/2 возвращает float. Используйте 1//2 для отсечения дробной части. (Этот синтаксис существует с Python 2.2)
- Константа sys.maxint была удалена, с тех пор, как более не существует предела значения целых чисел. Однако, sys.maxsize может быть использован как число, большее любого практического индекса списка или строки. sys.maxsize соответствует "естественному" размеру целого и, как правило, имеет такое же значение, как sys.maxint на той же платформе (при условии одних и те же параметров сборки).
- repr() от длинного целого числа не включает более завершающий символ L, так что код, который безусловно отрезает этот символ, будет отрезать вместо этого последнюю цифру. (Используйте str() вместо этого.)
- Восьмеричные литералы более не имеют формы вида 0720; используйте 0o720.
Текст, Unicode и 8-битные строки
Все, что вы знали о бинарных данных и Unicode, изменилось.
Python 3 использует понятия текста и (бинарных) данных вместо строк Unicode и 8-битных строк. Весь текст - Unicode; Однако кодированные Unicode строки представлены в виде двоичных данных. Тип, используемый для хранения текста является , тип, используемый для хранения данных - . Самое большое различие с python 2.x является то, что любая попытка комбинировать текст и данные в Python 3.0 поднимает TypeError, в то время как если бы вы смешивали Unicode и 8-битные строки в Python 2.x, это будет работать, если 8-битная строка содержала только 7-битные (ASCII) символы, но вы получите UnicodeDecodeError, если она содержит не-ASCII символы. Такое поведение вызывало многочисленные скорбные лица на протяжении многих лет.
Как следствие этого изменения в философии, значительная часть кода, который использует Unicode, кодировки или бинарные данные, скорее всего, должна измениться. Это изменения к лучшему, так как в python 2.x были многочисленные ошибки, имеющие отношение к смешиванию закодированного и декодированного текста. Чтобы быть подготовленным к этому, в Python 2.x следует начать использовать Unicode для всего незакодированного текста, и str только для бинарных или закодированных данных. Затем инструмент 2to3 будет делать большую часть работы за вас.
Вы можете больше не использовать литерал u"..." для текста Unicode. Тем не менее, вы должны использовать литерал b"..." для бинарных данных.
Так как str и bytes не могут быть смешаны, вы всегда должны их явно преобразовывать. Используйте str.encode(), чтобы перейти от str к bytes и bytes.decode(), чтобы перейти от bytes к str. Вы также можете использовать bytes(s, encoding=...) и str(b, encoding=...), соответственно.
Как str, тип bytes неизменен. Существует отдельный изменяемый тип для двоичных данных, bytearray. Почти все функции, которые принимают bytes также принимают bytearray.
Все обратные косые черты в "сырых" строковых литералах интерпретируются буквально. Это означает, что "\U" и "\u" в сырых строках не рассматриваются особо. Например, r"\u20ac" это строка из 6 символов в Python 3.0, в то время как в 2.6, ur"\u20ac" был один символ "евро". (Конечно, это изменение влияет только на сырые строковые литералы).
Встроенный абстрактный тип basestring был удален. Используйте str вместо него. str и bytes не имеют достаточно общей функциональности, чтобы оправдать общий базовый класс. Инструмент 2to3 (см. ниже) заменяет каждое вхождение basestring на str.
PEP 3138: repr() для строки больше не экранирует символы, не входящие в набор ASCII. Однако, он по-прежнему экранирует управляющие символы
PEP 3120: Кодировка исходного кода по умолчанию теперь UTF-8.
PEP 3131: не-ASCII символы разрешены в идентификаторах. (Тем не менее, стандартная библиотека остается ASCII, за исключением имен авторов в комментариях.)
Модули StringIO и cStringIO удалены. Вместо этого, импортируйте модуль io и используйте io.StringIO или io.BytesIO для текста и данных соответственно.
Обзор изменений синтаксиса
Этот раздел дает краткий обзор каждого синтаксического изменения Python 3.0.
Новый синтаксис
PEP 3107: аннотации для аргументов функции и возвращаемых значений.
>>> def foo (a : "x" , b : 5 + 6 , c : list ) -> max (2 , 9 ): ... pass >>> foo . __annotations__ {"a": "x", "b": 11, "c":PEP 3102: Keyword-only аргументы.
PEP 3104: nonlocal. Переменная во внешней (но не глобальной) области видимости.
>>> def outer (): ... x = 1 ... def inner (): ... x = 2 ... print ("inner:" , x ) ... inner () ... print ("outer:" , x ) ... >>> outer () inner: 2 outer: 1 >>> def outer (): ... x = 1 ... def inner (): ... nonlocal x ... x = 2 ... print ("inner:" , x ) ... inner () ... print ("outer:" , x ) ... >>> outer () inner: 2 outer: 2PEP 3132: Extended Iterable Unpacking
>>> (a , * rest , b ) = range (5 ) >>> a 0 >>> rest >>> b 4Генераторы словарей: {k: v for k, v in stuff} (то же самое, что и dict(stuff))
Литералы множеств (например, {1, 2}). Заметьте, что {} - это пустой словарь. Используйте set() для пустых множеств. Генераторы множеств: {x for x in stuff}
Новые восьмеричные литералы, например 0o720, вместо старых (0720).
Новые двоичные литералы, например 0b1010. Новая встроенная функция, bin().
Изменённый синтаксис
PEP 3109 and PEP 3134: новый синтаксис выражения raise: raise ].
"as" и "with" зарезервированные слова.
"True" и "False" и "None" - зарезервированные слова.
Изменено "except exc, var" на "except exc as var".
PEP 3115: Новый синтаксис для метаклассов. Вместо:
class C : __metaclass__ = M ...Вы должны использовать:
class C (metaclass = M ): ...Переменная __metaclass__ более не поддерживается.
Генераторы списков больше не поддерживают синтаксическую форму [... for var in item1, item2, ...]. Используйте [... for var in (item1, item2, ...)].
Удаленный синтаксис
PEP 3113: распаковка кортежей в параметрах удалена. Вы больше не можете писать
def foo (a , (b , c )): ... def foo (a , b_c ): b , c = b_c ...Удалены обратные кавычки (backtick). Используйте repr().
Удалено <>. Используйте!=.
exec - функция. Перестала быть зарезервированным словом.
from module import * запрещено использовать внутри функций.
Встроенные функции
PEP 3135: Новый super(). Теперь вы можете вызывать super() без аргументов и (при условии, что это метод экземпляра, определенный внутри определении класса) класс и экземпляр будут автоматически выбраны. С аргументами, поведение super() остается без изменений.
PEP 3111: raw_input() переименован в input(). Вместо input() в Python 2, вы можете использовать eval(input()).
Добавлена функция next(), вызывающая метод __next__() объекта.
Перемещен intern() в sys.intern().
Удалено: apply(). Вместо apply(f, args) используйте f(*args).
Удалено: callable(). Вместо callable(f) используйте hasattr(f, "__call__"). Функция operator.isCallable() также удалена.
Удалено: coerce().
Удалено: execfile(). Вместо execfile(fn) используйте exec(open(fn).read()).
Удалено: file. Используйте open().
Перемещено: reduce() в functools.reduce()
Перемещено: reload() в imp.reload().
Удалено: dict.has_key(). Используйте оператор in.