Вбудовані Типи

Основними вбудованими типами є числа, послідовності, словники, класи, екземпляри та винятки [doce]. У цьому розділі розглянуто лише найпростіші з них. Інші будуть розглянуті в майбутньому у відповідних темах.

Числові типи

Існує 3 різних числових типи: цілі числа, числа з плаваючою комою та комплексні числа. Крім того, булеві значення є підтипом цілих чисел. Цілі числа мають необмежену точність. Числа з плаваючою комою зазвичай реалізуються за допомогою double у C. Комплексні числа мають дійсну та уявну частини, кожна з яких є числом з плаваючою комою.

Числа створюються за допомогою числових літералів або як результат вбудованих функцій та операторів. Цілочислені літерали без додатків (включаючи шістнадцяткові, вісімкові та двійкові числа) створюють цілі числа. Числові літерали, що містять десяткову крапку або знак експоненти, дають числа з плаваючою комою. Додавання j або J до числового літерала дає уявне число (комплексне число з нульовою дійсною частиною), яке ви можете додати до цілого числа або числа з плаваючою комою, щоб отримати комплексне число з дійсною та уявною частинами.

Операції, які підтримуються

Операція

Результат

x + y

сума x і y

x - y

різниця x і y

x * y

добуток x і y

x / y

частка x і y

x // y

поділ націло x і y

x % y

залишок від ділення x / y

-x

x від’ємне

+x

x без змін

abs(x)

абсолютне значення або величина x

int(x)

x перетворене в ціле число

float(x)

x перетворене у число з плаваючою комою

complex(re, im)

комплексне число з дійсною частиною re та уявною частиною im. За замовчуванням im дорівнює нулю.

divmod(x, y)

об’єднує (x // y, x % y)

pow(x, y) x ** y

x у степені y

Примітка

x // y також називається цілочисельним діленням. Значення результату є цілим числом, оскільки тип результату не обов’язково int. Результат завжди округлюється до мінус нескінченності: 1 // 2 є 0

Примітка

float(x) також приймає рядки "nan" та "inf" з необов’язковим префіксом «+» або «-» для NaN(Not a Number)` та додатної і від’ємної нескінченності.

Приклади коду

Цілі числа
1>>> x = 42
2>>> y = 24
3>>> a = int(42)
4>>> b = int(42.24)
5>>> # result is of the integer type
6>>> result_add = x + y   # for both int operands only
7>>> result_sub = x - y   # for both int operands only
8>>> result_mul = x * y   # for both int operands only
9>>> result_div = x // y  # for any numeric operands
Числа з плаваючою комою
 1>>> x = 42.
 2>>> y = .24
 3>>> z = 42.24
 4>>> a = float(42)
 5>>> b = float(42.24)
 6>>> # result is of the float type
 7>>> result_add = x + y  # for any float operand
 8>>> result_sub = x - y  # for any float operand
 9>>> result_mul = x * y  # for any float operand
10>>> result_div = x / y  # for any numeric operands

Порівняння значень

Числа вбудованих числових типів можна порівнювати всередині та між типами (з обмеженням, що комплексні числа не підтримують порівняння порядків). У межах відповідних типів вони порівнюються математично коректно без втрати точності.

Значення «не-число» float("NaN") та decimal.Decimal('NaN') є спеціальними. Будь-яке впорядковане порівняння числа зі значенням «не-число» є хибним.

Типи послідовностей

Існує 3 основних типи послідовностей: списки, кортежі та об’єкти діапазону. Додаткові типи послідовностей, призначені для обробки двійкових даних і текстових рядків, описано у відповідних розділах.

Списки

Списки - це змінні послідовності, які зазвичай використовуються для зберігання колекцій елементів. Вони можуть бути побудовані кількома способами:

  • використовуючи пару квадратних дужок для позначення порожнього списку: []

  • використовуючи квадратні дужки, розділяючи елементи комами: [a], [a, b, c]

  • використовуючи генератори списків: [x for x in iterable]

  • використовуючи конструктор типу: list() або list(iterable)

Кортежі

Кортежі - це незмінні послідовності, які зазвичай використовуються для зберігання наборів даних або у випадках, коли потрібна незмінна послідовність даних (наприклад, для зберігання в екземплярах set або dict). Вони можуть бути побудовані кількома способами:

  • використовуючи пару круглих дужок для позначення порожнього кортежу: ()

  • з використанням кінцевої коми для одиночного кортежу: a, або (a, b, c)

  • розділення елементів комами: a, b, c або (a, b, c)

  • з використанням конструктора типу: tuple() або tuple(iterable)

Спільні операції

Операція

Результат

x in s x not in s

True, якщо елемент s дорівнює x False, якщо елемент s дорівнює x

s + t

конкатенація s та t

s * n

еквівалентно додаванню s до самого себе n разів

s[i]

i-й елемент з s, походження 0

s[i:j] s[i:j:k]

фрагмент s від i до j з кроком k. будь-який з них (або навіть всі 3) можна опустити.

len(s)

довжина s

min(s)

найменший елемент s

max(s)

найбільший елемент s

s.count(x)

загальна кількість входжень x у s

s.index(x) s.index(x, i) s.index(x, i, j)

індекс першого входження x у s на або після індексу i та перед індексом j

Порівняння значень

Послідовності можна порівнювати лише в межах кожного типу, з обмеженням, що діапазони не підтримують порівняння за порядком. Порівняння рівності між цими типами призводить до нерівності, а порівняння порядку між цими типами викликає TypeError.

Послідовності порівнюються лексикографічно за допомогою порівняння відповідних елементів. Вбудовані контейнери зазвичай вважають ідентичні об’єкти рівними собі. Лексикографічне порівняння між вбудованими колекціями працює наступним чином:

  • Для того, щоб дві колекції були рівними, вони повинні бути одного типу, мати однакову довжину і кожна пара відповідних елементів повинна порівнюватися однаково.

  • Колекції, що підтримують порівняння порядків, впорядковуються так само, як і їх перші нерівні елементи. Якщо відповідного елемента не існує, то спочатку впорядковується коротша колекція.

Типи змінних послідовностей

Операція

Результат

s[i] = x

елемент i в s замінюється на x

s[i:j] = t

фрагмент s від i до j, замінений вмістом t

del s[i:j]

те саме, що s[i:j] = []

s[i:j:k] = t

елементи s замінюються елементами t [1]

del s[i:j:k]

видаляє елементи s[i:j:k] зі списку

s.append(x)

додає x до кінця послідовності; те саме, що s[len(s):len(s)] = [x]

s.clear()

видаляє всі елементи з s (del s[:]) [2]

s.copy()

створює поверхневу копію s (s[:]) [2]

s.extend(t) s += t

розширює s вмістом t

s.insert(i, x)

вставляє x у s за індексом i; те саме, що s[i:i] = [x]

s.pop(), s.pop(i)

отримує елемент за адресою i, а також видаляє його з s (якщо i пропущено - використовуйте останній доступний індекс)

s.remove(x)

видалити перший елемент, який дорівнює x, із s

s.reverse()

перевертає елементи s на місце

Тип текстової послідовності

Методи рядків

Рядки реалізують всі звичайні операції з послідовністю, а також додаткові методи.

Порівняння значень

Рядки порівнюються лексикографічно, використовуючи числові кодові точки символів у Юнікоді.

Типи множин

Порівняння значень

Множини (екземпляри set або frozenset) можна порівнювати всередині та між їхніми типами. Вони визначають оператори порівняння порядку, які означають тести підмножин та надмножин. Ці відношення не визначають повного впорядкування (наприклад, дві множини {1, 2} і {2, 3} не є рівними, не є підмножинами одна одної і не є надмножинами одна одної).

Тип відображення

Об’єкт зіставлення зіставляє хешовані значення з довільними об’єктами. Відображення є змінними об’єктами. Наразі існує лише один стандартний тип відображення, dictionary. Якщо кількома словами, то відображення - це набори ключів та їхніх значень.

Ключі словника - це майже довільні значення. Значення, які не піддаються хешуванню, не можна використовувати як ключі. Значення, які порівнюються як рівні (наприклад, 1, 1.0 і True), можуть використовуватися як взаємозамінні для індексації однієї і тієї ж словникової статті.

Словники можна створювати кількома способами:

  • Використовуйте дужки для позначення порожнього словника: {}

  • Використовуйте список пар key: value через кому з дужками: {'first_name': 'Serhii', 'last_name': 'Horodilov', 'age': 34}

  • Використовуючи генератори списків: {x: x 2 for x in range(10)}

  • Використовуйте конструктор типу: dict(), dict([('key', 100)]), dict(key=100)

Порівняння значень

Екземпляри dict порівнюються однаково тоді і тільки тоді, коли вони мають однакові пари ключ-значення.

Порівняння порядку викликає TypeError.