Встроенные типы данных.

Как уже говорилось, все данные в Python представлены объектами. Имена являются лишь ссылками на эти объекты и не несут нагрузки по декларации типа. Значения встроенных типов имеют специальную поддержку в синтаксисе языка: можно записать литерал строки, числа, списка, кортежа, словаря (и их разновидностей). Синтаксическую же поддержку операций над встроенными типами можно легко сделать доступной и для объектов определяемых пользователей классов.

Следует также отметить, что объекты могут быть неизменчивыми и изменчивыми. Например, строки в Python являются неизменчивыми, поэтому операции над строками создают новые строки.

Карта встроенных типов (с именами функций для приведения к нужному типу и именами классов для наследования от этих типов):

• специальные типы: None, NotImplemented и Ellipsis;

• числа;

 ○ целые.

  • обычное целое int.

  • целое произвольной точности long.

  • логический bool.

 ○ число с плавающей точкой float.

 ○ комплексное число complex.

• последовательности;

 ○ неизменчивые:

  • строка str;

  • Unicode–строка unicode;

  • кортеж tuple;

 ○ изменчивые:

  • список list;

• отображения:

 ○ словарь dict.

• объекты, которые можно вызвать:

 ○ функции (пользовательские и встроенные);

 ○ функции–генераторы;

 ○ методы (пользовательские и встроенные);

 ○ классы (новые и «классические»);

 ○ экземпляры классов (если имеют метод __call__);

• модули;

• классы (см. выше);

• экземпляры классов (см. выше);

• файлы file;

• вспомогательные типы buffer, slice.

Узнать тип любого объекта можно с помощью встроенной функции type().

Тип int и long.

Два типа: int (целые числа) и long (целые произвольной точности) служат моделью для представления целых чисел. Первый соответствует типу long в компиляторе C для используемой архитектуры. Числовые литералы можно записать в системах счисления с основанием 8, 10 или 16:

# В этих литералах записано число 10.

Print 10, 012, 0xA, 10L.

Набор операций над числами — достаточно стандартный как по семантике, так и по обозначениям:

>>> print 1 + 1, 3 — 2, 2*2, 7/4, 5%3.

2 1 4 1 2.

>>> print 2L ** 1000.

107150860718626732094842504906000181056140481170553360744375038.

837035105112493612249319837881569585812759467291755314682518714.

528569231404359845775746985748039345677748242309854210746050623.

711418779541821530464749835819412673987675591655439460770629145.

71196477686542167660429831652624386837205668069376.

>>> print 3 < 4 < 6, 3 >= 5, 4 == 4, 4 != 4 # сравнения.

True False True False.

>>> print 1 << 8, 4 >> 2, ~4 # побитовые сдвиги и инверсия.

256 1–5.

>>> for i, j in (0, 0), (0, 1), (1, 0), (1, 1):

... print i, j, ":", i & j, i | j, i ^ j # побитовые операции.

...

0 0 : 0 0 0.

0 1 : 0 1 1.

1 0 : 0 1 1.

1 1 : 1 1 0.

Значения типа int должны покрывать диапазон от–2147483648 до 2147483647, а точность целых произвольной точности зависит от объема доступной памяти.

Стоит заметить, что если в результате операции получается значение, выходящее за рамки допустимого, тип int может быть неявно преобразован в long:

>>> type(-2147483648).

<type 'int'>

>>> type(-2147483649).

<type 'long'>

Также нужно быть осторожным при записи констант. Нули в начале числа — признак восьмеричной системы счисления, в которой нет цифры 8:

>>> 008.

 File "<stdin>", line 1.

 008.

   ^

SyntaxError: invalid token.

Тип float.

Соответствует C–типу double для используемой архитектуры. Записывается вполне традиционным способом либо через точку, либо в нотации с экспонентой:

>>> pi = 3.1415926535897931.

>>> pi ** 40.

7.6912142205156999e+19.

Кроме арифметических операций, можно использовать операции из модуля math.

Примечание: Для финансовых расчетов лучше применять более подходящий тип. 

Из полезных встроенных функций можно вспомнить round(), abs().

Тип complex.

Литерал мнимой части задается добавлением j в качестве суффикса (перемножаются мнимые единицы):

>>> -1j * -1j.

(-1–0j).

Тип реализован на базе вещественного. Кроме арифметических операций, можно использовать операции из модуля cmath.

Тип bool.

Подтип целочисленного типа для «канонического» обозначения логических величин. Два значения: True (истина) и False (ложь) — вот и все, что принадлежит этому типу. Как уже говорилось, любой объект Python имеет истинностное значение, логические операции можно проиллюстрировать с помощью логического типа:

>>> for i in (False, True):

...  for j in (False, True):

...   print i, j, ":", i and j, i or j, not i.

...

...

False False : False False True.

False True : False True True.

True False : False True False.

True True : True True False.

Следует отметить, что Python даже не вычисляет второй операнд операции and или or, если ее исход ясен по первому операнду. Таким образом, если первый операнд истинен, он и возвращается как результат or, в противном случае возвращается второй операнд. Для операции and все аналогично.

Тип string и тип unicode.

В Python строки бывают двух типов: обычные и Unicode–строки. Фактически строка — это последовательность символов (в случае обычных строк можно сказать «последовательность байтов»). Строки–константы можно задать в программе с помощью строковых литералов. Для литералов наравне используются как апострофы ( '), так и обычные двойные кавычки ( "). Для многострочных литералов можно использовать утроенные апострофы или утроенные кавычки. Управляющие последовательности внутри строковых литералов задаются обратной косой чертой ( \). Примеры написания строковых литералов:

S1 = "строка1".

S2 = 'строка2\nс переводом строки внутри'.

S3 = """строка3.

С переводом строки внутри""".

U1 = u'\u043f\u0440\u0438\u0432\u0435\u0442' # привет.

U2 = u'Еще пример' # не забудьте про coding!

Для строк имеется еще одна разновидность: необработанные строковые литералы. В этих литералах обратная косая черта и следующие за ней символы не интерпретируются как спецсимволы, а вставляются в строку «как есть»:

My_re = r"(\d)=\1".

Обычно такие строки требуются для записи регулярных выражений (о них пойдет речь в лекции, посвященной обработке текстовой информации).

Набор операций над строками включает конкатенацию « +», повтор " *", форматирование " %". Также строки имеют большое количество методов, некоторые из которых приведены ниже. Полный набор методов (и их необязательных аргументов) можно получить в документации по Python.

>>> "A" + "B".

'AB'.

>>> "A"*10.

'AAAAAAAAAA'.

>>> "%s %i" % ("abc", 12).

'abc 12'.

Некоторые методы строковых объектов будут рассмотрены в лекции, посвященной обработке текстов.

Тип tuple.

Для представления константной последовательности (разнородных) объектов используется тип кортеж. Литерал кортежа обычно записывается в круглых скобках, но можно, если не возникают неоднозначности, писать и без них. Примеры записи кортежей:

P = (1.2, 3.4, 0.9) # точка в трехмерном пространстве.

For s in "one", "two", "three": # цикл по значениям кортежа.

Print s.

One_item = (1,).

Empty = ().

P1 = 1, 3, 9 # без скобок.

P2 = 3, 8, 5, # запятая в конце игнорируется.

Использовать синтаксис кортежей можно и в левой части оператора присваивания. В этом случае на основе вычисленных справа значений формируется кортеж и связывается один в один с именами в левой части. Поэтому обмен значениями записывается очень изящно:

A, b = b, a.

Тип list.

В «чистом» Python нет массивов с произвольным типом элемента. Вместо них используются списки. Их можно задать с помощью литералов, записываемых в квадратных скобках, или посредством списковых включений. Варианты задания списка приведены ниже:

Lst1 = [1, 2, 3,].

Lst2 = [x**2 for x in range(10) if x % 2 == 1].

Lst3 = list("abcde").

Для работы со списками существует несколько методов, дополнительных к тем, что имеют неизменчивые последовательности. Все они связаны с изменением списка.

Последовательности.

Ниже обобщены основные методы последовательностей. Следует напомнить, что последовательности бывают неизменчивыми и изменчивыми. У последних методов чуть больше.

Синтаксис	Семантика
len(s)	Длина последовательности s
x in s	Проверка принадлежности элемента последовательности. В новых версиях Python можно проверять принадлежность подстроки строке. Возвращает True или False
x not in s	= not x in s
s + s1	Конкатенация последовательностей
s*n или n*s	Последовательность из n раз повторенной s. Если n < 0, возвращается пустая последовательность.
s[i]	Возвращает i–й элемент s или len(s)+i–й, если i < 0
s[i:j:d]	Срез из последовательности s от i до j с шагом d будет рассматриваться ниже
min(s)	Наименьший элемент s
max(s)	Наибольший элемент s

Дополнительные конструкции для изменчивых последовательностей:

s[i] = x	i–й элемент списка s заменяется на x
s[i:j:d] = t	Срез от i до j (с шагом d) заменяется на (список) t
del s[i:j:d]	Удаление элементов среза из последовательности

Некоторые методы для работы с последовательностями.

В таблице приведен ряд методов изменчивых последовательностей (например, списков).

Метод	Описание
append(x)	Добавляет элемент в конец последовательности
count(x)	Считает количество элементов, равных x
extend(s)	Добавляет к концу последовательности последовательность
index(x)	Возвращает наименьшее i, такое, что s[i] == x. Возбуждает исключение ValueError, если x не найден в s
insert(i, x)	Вставляет элемент x в i–й промежуток
pop(i)	Возвращает i–й элемент, удаляя его из последовательности
reverse()	Меняет порядок элементов s на обратный
sort([cmpfunc])	Сортирует элементы s. Может быть указана своя функция сравнения cmpfunc

Взятие элемента по индексу и срезы.

Здесь же следует сказать несколько слов об индексировании последовательностей и выделении подстрок (и вообще — подпоследовательностей) по индексам. Для получения отдельного элемента последовательности используются квадратные скобки, в которых стоит выражение, дающее индекс. Индексы последовательностей в Python начинаются с нуля. Отрицательные индексы служат для отсчета элементов с конца последовательности ( -1 — последний элемент). Пример проясняет дело:

>>> s = [0, 1, 2, 3, 4].

>>> print s[0], s[-1], s[3].

0 4 3.

>>> s[2] = -2.

>>> print s.

[0, 1, -2, 3, 4].

>>> del s[2].

>>> print s.

[0, 1, 3, 4].

Примечание: Удалять элементы можно только из изменчивых последовательностей и желательно не делать этого внутри цикла по последовательности.

Несколько интереснее обстоят дела со срезами. Дело в том, что в Python при взятии среза последовательности принято нумеровать не элементы, а промежутки между ними. Поначалу это кажется необычным, тем не менее, очень удобно для указания произвольных срезов. Перед нулевым (по индексу) элементом последовательности промежуток имеет номер 0, после него — 1 и т.д.. Отрицательные значения отсчитывают промежутки с конца строки. Для записи срезов используется следующий синтаксис:

Последовательность[нач:кон:шаг].

Где нач — промежуток начала среза, кон — конца среза, шаг — шаг. По умолчанию нач=0, кон=len(последовательность), шаг=1, если шаг не указан, второе двоеточие можно опустить.

А теперь пример работы со срезами:

>>> s = range(10).

>>> s.

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

>>> s[0:3].

[0, 1, 2].

>>> s[-1:].

[9].

>>> s[::3].

[0, 3, 6, 9].

>>> s[0:0] = [-1, -1, -1].

>>> s.

[-1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

>>> del s[:3].

>>> s.

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].

Как видно из этого примера, с помощью срезов удобно задавать любую подстроку, даже если она нулевой длины, как для удаления элементов, так и для вставки в строго определенное место.

Тип dict.

Словарь (хэш, ассоциативный массив) — это изменчивая структура данных для хранения пар ключ–значение, где значение однозначно определяется ключом. В качестве ключа может выступать неизменчивый тип данных (число, строка, кортеж и т.п.). Порядок пар ключ–значение произволен. Ниже приведен литерал для словаря и пример работы со словарем:

D = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}.

D0 = {0: 'zero'}.

Print d[1] # берется значение по ключу.

D[0] = 0   # присваивается значение по ключу.

Del d[0]   # удаляется пара ключ–значение с данным ключом.

Print d.

For key, val in d.items(): # цикл по всему словарю.

 print key, val.

For key in d.keys(): # цикл по ключам словаря.

 print key, d[key].

For val in d.values(): # цикл по значениям словаря.

 print val.

D.update(d0) # пополняется словарь из другого.

Print len(d) # количество пар в словаре.

Тип file.

Объекты этого типа предназначены для работы с внешними данными. В простом случае — это файл на диске. Файловые объекты должны поддерживать основные методы: read(), write(), readline(), readlines(), seek(), tell(), close() и т.п.

Следующий пример показывает копирование файла:

F1 = open("file1.txt", "r").

F2 = open("file2.txt", "w").

For line in f1.readlines():

 f2.write(line).

F2.close().

F1.close().

Стоит заметить, что кроме собственно файлов в Python используются и файлоподобные объекты. В очень многих функциях просто неважно, передан ли ей объект типа file или другого типа, если он имеет все те же методы (и в том же смысле). Например, копирование содержимого по ссылке (URL) в файл file2.txt можно достигнуть, если заменить первую строку на.

Import urllib.

F1 = urllib.urlopen("http://python.onego.ru").

О модулях, классах, объектах и функциях будет говориться на других лекциях.