Типы данных в python

Числовой тип данных в Python

Python поддерживает целые числа, числа с плавающей точкой (так же называемые числами с плавающей запятой) и комплексные числа. Они определены как int, float и комплексный класс в Python.

Целые числа и числа с плавающей точкой разделены наличием или отсутствием десятичной точки. 5 — целое число, тогда как 5.0 — число с плавающей точкой.

Комплексные числа записываются в виде x + yj, где x — действительная часть, а y — мнимая часть.

Мы можем использовать функцию type(), чтобы узнать, какому классу принадлежит переменная или значение, и функцию isinstance(), чтобы проверить, принадлежит ли она определенному классу.

a = 5

# результат: <class 'int'>
print(type(a))

# результат: <class 'float'>
print(type(5.0))

# результат: (8+3j)
c = 5 + 3j
print(c + 3)

# результат: True
print(isinstance(c, complex))

Хотя целые числа могут быть любой длины, число с плавающей запятой является точным только до 15 десятичных знаков (16-е место — неточно).

Числа, с которыми мы имеем дело каждый день, — это десятичная система счисления. Но программистам часто приходится работать с двоичными, шестнадцатеричными и восьмеричными системами счисления.

В Python мы можем представить эти числа, поместив префикс перед этим числом. Ниже перечислены эти префиксы.

• Двоичный «0b» или «0B»
• Восьмеричный ‘0o’ или ‘0O’
• Шестнадцатеричный ‘0x’ или ‘0X’

# результат: 107
print(0b1101011)

# результат: 253 (251 + 2)
print(0xFB + 0b10)

# результат: 13
print(0o15)

Константы в Python

Константа — это тип переменной, значение которой нельзя изменить на протяжении всего жизненного цикла программы. Однако в Python, это носит скорее рекомендательный характер. Дело в том, что в отличии от многих языков программирования, в которых присвоение нового значения константе вызовет ошибку, в Python значение константы может быть изменено и это не вызовет вопросов со стороны интерпретатора.

При объявлении константы вы как бы говорите себе и другим программистам которые возможно будут читать ваш код «Значение этой переменной не должно меняться на протяжении всего цикла работы программы!».

Как объявить константу в Python

Как и обычная переменная (а константа в Python, технически, это обычная переменная) константа инициализируется в момент присвоения ей значения:

PI = 3.14

Имя константы пишется в верхнем регистре (PI, MESSAGE и т.д.) с целью выделить ее, дать понять что это именно константа и ее значение должно оставаться неизменным. Если в имени присутствуют два или больше слов, то они разделяются символом подчеркивания (WELCOME_MESSAGE).

Словари

Словари — это хеш-таблицы или неупорядоченные наборы пар типа «ключ-значение». Работают, как ассоциативные массивы. Используются, если нужно сопоставить значение какому-нибудь ключу, чтобы иметь возможность получить доступ к этому значению, имея соответствующий ключ. В других языках программирования словари называют map, hash, object.

Словарь оптимизирован для извлечения данных. Он объявляется парами элементов в виде ключ:значение, которые заключены в фигурные скобки:

>>> d = {1'value', 'key'2}
>>> type(d)
<class 'dict'>

Ключ используется для получения значения, которое ему соответствует. Не наоборот!

>>> d = {1'value', 'key'2}
>>> print("d =", d1]);
d1 = value
>>> print("d =", d'key']);
d'key' = 2
# Приведёт к ошибке
>>> print("d =", d2]);

Числа

Для хранения числовых значений используют числовые типы данных. Создание числовых объектов не вызывает затруднений:

var1 = 1
var2 = 10

Ссылка на числовой объект без проблем удаляется с помощью оператора del. Синтаксис:

del var1]]]

В Python поддерживаются 3 разных числовых типа:
— целые числа со знаком (int);
— значения с плавающей запятой (float);
— комплексные числа (complex).

В Python 3 все целые числа представлены как long числа, то есть отдельного типа long нет.

Чтобы узнать класс переменной либо значения, мы можем использовать функции type() и isinstance(). Это позволяет проверить принадлежность объекта конкретному классу:

>>> a = 5
>>> print(a, "is of type", type(a))
5 is of type <class 'int'>
>>> a = 2.0
>>> print(a, "is of type", type(a))
2.0 is of type <class 'float'>
>>> a = 1+2j
>>> print(a, "is complex number?", isinstance(1+2j, complex))
(1+2j) is complex number? True

У чисел с плавающей запятой ограниченная точность. Визуально разница видна в консоли по наличию точки: 1.0 — число с плавающей запятой, 1 — целое число.

Что касается комплексных чисел, то они записываются в виде x+yj. Х в данном случае — действительная часть числа, Y — мнимая. Примеры:

>>> a = 1234567890123456789
>>> a
1234567890123456789
>>> b = 0.1234567890123456789
>>> b
0.12345678901234568
>>> c = 1+2j
>>> c
(1+2j)

Здесь следует учесть, что значение переменной b усечено.

Стандартный метод

Самый простой и очевидный вариант уничтожения ненужных диалогов – использование интерфейса Вконтакте. Чтобы разобраться, как быстро удалить все сообщения в Вк, потребуется:

1. авторизоваться на сайте;
2. перейти в раздел сообщений;
3. кликнуть переписку, которую необходимо уничтожить;
4. навести курсор на короткое ниспадающее меню над диалогом;
5. нажать на пункт «очистить историю».

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

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

Ещё одно понятие из математики. Там, последовательность – есть нумерованный набор элементов, в котором возможны их повторения, а порядок имеет значение. Определение Питона схоже с математическим: здесь последовательностью зовётся упорядоченная коллекция объектов.

str (строка)

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

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

Строки, строки everywhere!

list (список)

Список – это ещё один вид последовательностей… Здесь стоит остановиться и отметить, что последовательности в Python бывают изменяемыми и неизменяемыми. Список – изменяемая последовательность, а строки и кортежи – нет. Таким образом, список можно определить, как упорядоченную и изменяемую коллекцию, состоящую из объектов произвольных типов.

Само название списков говорит об их предназначении быть объектами для хранения наборов данных. Список покупок, подарков, результатов матчей, ip клиентов или объектов типа Student. Списки в Python – это эдакие массивы из прочих языков «на максималках».

tuple (кортеж)

Кортежи в языке Python можно рассматривать, как неизменяемые списки со всеми вытекающими:

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

Условный оператор

В языке python синтаксис обладает интересной особенностью: дело в том, что в коде нет операторных скобок ( или ); вместо них отступы указывают, какие операторы выполнять внутри той или иной конструкции.
Зачем отступы и где их ставить?

1
2
3
4

if x > :
  if x < 2:
else:
  оператор

Следует обратить внимания, что знак сравнения в Питоне записывается, как два знака :

1
2
3
4
5
6

if x < :
  блок1
elif x == : # сравнение!
  блок2
else:
  блок3

Другой пример использования условия:

1
2
3
4
5
6

if x < :
    print('мало')
elif x == :
    print('средне')
else:
    print('много')

Сложные условия

• Использование двойных неравенств разрешено:

1
2
3
4

if  < x < 2:
  if  < y < 2:
else:
  оператор

Пример использования условия c :

1
2
3
4
5
6

if x < :
    print('мало')
elif - <= x <= :
    print('средне')
else:
    print('много')

Кроме того, можно применять логический оператор (И):

if x >= 30 and x <= 40:
 ...

Использование с оператором :

site = "my.ru"
 
if "ru" in site:
    print("Условие выполнено!") # Условие выполнено!

Кроме того, можно применять логический оператор (ИЛИ):

site = "my.ru"
 
if "my" in site or site.endswith(".ru"): # заканчивается на ...
    print("Условие выполнено!")

Аналог тернарного оператора:

uchenik_1 = 5
uchenik_2 = 2
 
otlichnik = "первый ученик" if uchenik_1 > uchenik_1  else "второй ученик"
 
print(otlichnik) # первый ученик

Задание Python 1_6: Запрашивается количество часов и заработок в час. Рассчитать зарплату. Если работник работал более 40 часов, — то зарплата умножается на коэффициент 1,5. Оформить в формате дружелюбного интерфейса.

Пример: Дан год. Определить високосный ли год или нет? Вывести или (логическое значение).Указания: Год является високосным если он кратен 4, но при этом не кратен 100, либо кратен 400.

Решение:

year = 2017
is_true = year % 4 ==  and (year % 100 !=  or year % 400 == )
print(is_true)

Задание Python 1_7: Напишите программу, которая определяет, верно ли, что введённое число – четырёхзначное. Вывести или (логическое значение).

Задание Python 1_8: Напишите программу, которая вводит с клавиатуры номер месяца и определяет, сколько дней в этом месяце. Предусмотреть сообщение об ошибке в случае ввода неверного числа.

! Решения заданий можно попросить у администратора, выслав письмо с запросом на электронный адрес (внизу веб-страницы). В письме укажите Ваши ФИО, город, должность (учитель/ученик/студент). Укажите, занимаетесь ли самостоятельно и номер урока, решения которого необходимо выслать.

Типы данных и преобразование типов

Перечислим основные типы данных в Python, которые понадобятся на ближайших уроках:

• int – целочисленные значения;float – вещественные (дробные) значения;bool – логические значения — истина (True) или ложь (False);str – символьная строка или единичный символ.

Рассмотрим примеры использования основных типов в Python:Целые числа (int):

num = 13
print(num)  # 13
 
num = 
print(num)  # 0
 
num = -10
print(num)  # -10
 
num = 500_000_000  # для удобства чтения
print(num) # 500000000

Вещественные числа (float):

num = 13.4
print(num) # 13.4
 
num = 0.0
print(num) # 0.0
 
num = -15.2
print(num) # -15.2
 
num = 100_000.000_002 # для удобства чтения
print(num) # 100000.000002
 
num = 1.7e2 # 1.7 умножить на 10 в степени 2
print(num) # 170

Логический тип (bool):

print(15 == 15) # True
 
print(1 != 3) # True
 
print(3 > 4) # False
 
print(3 <= 3) # True
 
print(6 >= 6) # True
 
print(6 < 5) # False
 
x = 2
print(1 < x < 3) # True

Строки (str):

example_string = "Очень интересно"
print(example_string) # Очень интересно
 
example_string = 'Пьеса "На дне"'
print(example_string) # Пьеса "На дне"
 
example_string = "Пьеса \"На дне\"
print(example_string) # Пьеса "На дне"
 
example_string = "Как " \
                 "разбить " \
                 "объявление длинной строки"
print(example_string) # Как разбить объявление длинной строки
 
example_string = """
                 Как  
                 оставить сроку
                 в несколько строк
                 """
print(example_string) 
# Как  
# оставить сроку
# в несколько строк

# Как объединить две строки в одну
print("Можно их" + " сложить") # Можно их сложить 
 
print("Можно и так!" * 3) # Можно и так!Можно и так!Можно и так!

Рассмотрим примеры того, как используется преобразование типов в Питон:

• преобразование в символьную строку:

1
2
3

a = 1.7
a=str(a)
print(a) # '1.7'

преобразование в целое:

1
2
3

x = 1.7
x=int(x)
print(x) # 1

преобразование в вещественное:

1
2
3

y=1
y=float(y)
print(y) # 1.0

Использование модуля pickle на своих объектах

протокол

Сериализация собственных объектов.

• Если вы хотите, чтобы после десериализации вашего класса был вызыван , вы можете определить , который должен вернуть кортеж аргументов, который будет отправлен в . Заметьте, что этот метод работает только с классами старого стиля.

• Для классов нового стиля вы можете определить, какие параметры будут переданы в во время десериализации. Этот метод так же должен вернуть кортеж аргументов, которые будут отправлены в .

• Вместо стандартного атрибута , где хранятся атрибуты класса, вы можете вернуть произвольные данные для сериализации. Эти данные будут переданы в во время десериализации.

• Если во время десериализации определён , то данные объекта будут переданы сюда, вместо того чтобы просто записать всё в . Это парный метод для : когда оба определены, вы можете представлять состояние вашего объекта так, как вы только захотите.

• Если вы определили свой тип (с помощью Python’s C API), вы должны сообщить Питону как его сериализовать, если вы хотите, чтобы он его сериализовал. вызывается когда сериализуется объект, в котором этот метод был определён. Он должен вернуть или строку, содержащую имя глобальной переменной, содержимое которой сериализуется как обычно, или кортеж. Кортеж может содержать от 2 до 5 элементов: вызываемый объект, который будет вызван, чтобы создать десериализованный объект, кортеж аргументов для этого вызываемого объекта, данные, которые будут переданы в (опционально), итератор списка элементов для сериализации (опционально) и итератор словаря элементов для сериализации (опционально).

• Иногда полезно знать версию протокола, реализуя . И этого можно добиться, реализовав вместо него . Если реализован, то предпочтение при вызове отдаётся ему (вы всё-равно должны реализовать для обратной совместимости).

ИГУМО и ИТ, Институт гуманитарного образования и информационных технологий

г. Москва

Факультет  Фотографии

Факультет фотографии ИГУМО — единственный факультет в Москве, на котором готовят профессиональных фотографов по программе бакалавриата.

На факультете регулярно проходят мастер-классы знаменитых фотографов. Для студентов организуются выездные занятия и экскурсии по крупнейшим выставочным площадкам Москвы.

В рамках прохождения практики студенты факультета фотографии работают на крупных проектах. В 2016–2017 учебном году студенты проходили практику на 137-й Ассамблее Межпарламентского союза (Санкт-Петербург), в посольстве Индии, в посольстве Чешской Республики, на Всероссийском форуме «Наставник», на Втором Форуме социальных инноваций регионов, а также на конкурсе «Nikon: я в сердце изображения».

Замена в строке

Чтобы в Python заменить в строке одну подстроку на другую, применяют метод replace():
• replace(old, new): подстрока old заменяется на new;
• replace(old, new, num): параметр num показывает, сколько вхождений подстроки old требуется заменить на new.

Пример замены в строке в Python:

    phone = "+1-234-567-89-10"

# дефисы меняются на пробелы
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# дефисы удаляются
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# меняется только первый дефис
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

Как изменить или удалить строку?

Строки относятся к неизменяемым типам данных (immutable type). Это означает, что элементы строки не могут быть изменены после того, как она была создана. Мы можем просто переназначить разные строки одному и тому же имени.

>>> my_string = 'programfiles'
>>> my_string = 'a'
...
TypeError: 'str' object does not support item assignment
>>> my_string = 'Python'
>>> my_string
‘Python'

Мы не можем удалять символы из строки. Но полностью удалить строку можно с помощью ключевого слова del.

>>> del my_string
...
TypeError: 'str' object doesn't support item deletion
>>> del my_string
>>> my_string
...
NameError: name 'my_string' is not defined

Преобразование типа

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

• Неявное преобразование типов
• Явное приведение типов

Неявное преобразование типов

При неявном преобразовании типов Python автоматически преобразует один тип данных в другой тип данных. Этот процесс не требует участия пользователя.

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

Пример 1: преобразование целого числа в число с плавающей точкой

num_int = 123
num_float = 1.23

num_new = num_int + num_float

print("тип данных num_int:",type(num_int))
print("тип данных num_float:",type(num_float))

print("значение num_new:",num_new)
print("тип данных num_new:",type(num_new))

Давайте рассмотрим этот пример преобразования типа подробнее:

1. мы добавляем две переменные num_int и num_float, сохраняя значение в num_new
2. мы выводим тип данных всех трех объектов соответственно
3. в выводе мы можем видеть, что тип данных num_int является целым числом, тип данных num_float — это число с плавающей точкой
4. кроме того, мы можем видеть, что num_new имеет тип данных float, потому что Python всегда преобразует меньший тип данных в больший тип данных, чтобы избежать потери данных

Подробнее преобразование типа int в float и обратно, рассмотрено в статье Числа в Python.

Теперь давайте попробуем добавить строку и целое число и посмотрим, как Python отнесется к этому.

Пример 2: сложение строкового (более высокого) типа данных и целочисленного (более низкого) типа данных

num_int = 123
num_str = "456"

print("тип данных num_int:",type(num_int))
print("тип данных num_str:",type(num_str))

print(num_int+num_str)

Если запустить приведенный выше пример, вы сначала увидите вывод типа данных двух наших переменных, а затем сообщение об ошибке. В данном случае, интерпретатор «не понял» что ему делать со значениями двух переменных, так как сложить число и строку не представляется возможным. Однако у Python есть решение для такого типа ситуаций, которое известно как явное преобразование.

Явное приведение типов

В явном преобразовании типов пользователи сами преобразуют тип данных объекта в требуемый тип данных. Мы используем предопределенные функции, такие как int(), float(), str() и т.д., чтобы выполнить явное преобразование типов.

Это преобразование типов также называется явным приведением типов, поскольку пользователь явно преобразует (изменяет) тип данных объектов.

Typecasting может быть выполнен путем назначения требуемой функции типа данных для выражения.

Пример 3: добавление строки и целого числа с использованием явного преобразования

num_int = 123
num_str = "456"

print("тип данных num_int:",type(num_int))
print("тип данных num_str до приведения типа :",type(num_str))

num_str = int(num_str)
print("тип данных num_str после приведения типа:",type(num_str))

num_sum = num_int + num_str

print("сумма num_int и num_str:",num_sum)
print("тип данных num_sum:",type(num_sum))

Разбиение строки

Для анализа текста требуются различные метрики, такие как количество слов, количество символов, средняя длина предложения. Чтобы вычислить эти значения, нам нужно подготовить текст — очистить и разделить. К счастью для нас, в Python есть несколько встроенных функций для разделения текста:

Разбиение по пробелу (по умолчанию):

test_string.split()
Out: 

Разбиение на определенное количество токенов:

test_string.split(' ', 2)
Out: 

Разбиение на определенное количество токенов в обратном направлении:

test_string.rsplit(' ', 2)
Out: 

Разбиение по произвольному символу:

test_string.split('e')
Out: 

Разбиение строки по нужному токену с токенами до и после него:

test_string.partition('fox')
Out: ('The quick brown ', 'fox', ' jumps over the lazy dog')

Используем рекурсию

# Python code to reverse a string  
# using recursion 
  
def reverse(s): 
    if len(s) == 0: 
        return s 
    else: 
        return reverse(s) + s 
  
s = "Pythonist"
  
print ("The original string  is : ",end="") 
print (s) 
  
print ("The reversed string(using recursion) is : ",end="") 
print (reverse(s)) 

The original string  is : Pythonist
The reversed string(using recursion) is : tsinohtyP  

Объяснение: В приведенном выше коде строка передается в качестве аргумента рекурсивной функции для обращения строки. В функции основное условие состоит в том, что если длина строки равна 0, строка возвращается. Если не равно 0, рекурсивно вызывается обратная функция, чтобы разрезать часть строки, оставив первый символ, и объединить первый символ с концом отрезанной строки.

Преобразование в кортежи и списки

Чтобы преобразовать данные в кортеж или список, используйте методы tuple() и list() соответственно. В Python:

• Список – это изменяемая упорядоченная последовательность элементов, взятая в квадратные скобки ().
• Кортеж – неизменяемая упорядоченная последовательность элементов, взятая в круглые скобки.

Преобразование списка в кортеж

Преобразовывая список в кортеж, вы можете оптимизировать программу. Для преобразования в кортеж используется метод tuple().

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

Попробуйте использовать tuple() с переменной:

В кортеж можно преобразовать любой итерируемый тип, включая строки:

Конвертируя в кортеж числовой тип данных, вы получите ошибку:

Преобразование в списки

Вы можете преобразовать кортеж в список, чтобы сделать его изменяемым.

Обратите внимание: при этом в методах list() и print() используется две пары круглых скобок. Одни принадлежать собственно методу, а другие – кортежу

Если данные, которые вывел метод print, заключены в квадратные скобки, значит, кортеж преобразовался в список.

Чтобы избежать путаницы с круглыми скобками, можно создать переменную:

Строки тоже можно преобразовывать в списки:

Strip и zfill

Еще одна важная функция — это возможность удалять из строки лишние начальные и конечные символы. Для этого у нас есть семейство функций :

• Удалить пробелы по умолчанию.
• Удалить пробелы слева или справа.
• Удалить произвольные символы.

test_string_with_spaces = '     The quick brown fox jumps over the lazy dog    '
test_string_with_spaces.strip()

Out: 'The quick brown fox jumps over the lazy dog'

test_string_with_spaces.lstrip()

Out: 'The quick brown fox jumps over the lazy dog    '

test_string_with_spaces.rstrip()

Out: '     The quick brown fox jumps over the lazy dog'

test_string.rstrip('g')

Out: 'The quick brown fox jumps over the lazy do'

Кроме того, есть полезная функция для дополнения чисел ведущими нулями:

'29'.zfill(10)

Out: '0000000029'

'xA1'.zfill(4)

Out: '0xA1'

Словари

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

Вы можете получить список ключей путем вызова метода keys() в том или ином словаря. Чтобы проверить, присутствует ли ключ в словаре, вы можете использовать ключ in в Python. В некоторых старых версиях Python (с 2.3 и более ранних, если быть точным), вы увидите ключевое слово has_key, которое используется для проверки наличия ключа в словаре. Данный ключ является устаревшим в Python 2.X, и был удален, начиная с версии 3.Х. Давайте попробуем создать наш первый словарь:

Python

my_dict = {}
another_dict = dict()

my_other_dict = {«one»:1, «two»:2, «three»:3}
print(my_other_dict) # {‘three’: 3, ‘two’: 2, ‘one’: 1}

Первые два примера показывают, как создавать пустой словарь. Все словари находятся в фигурных скобках. Последняя строчка показывает, что мы имеем в виду, когда говорим «неупорядоченный словарь». Теперь настало время узнать, как принимаются значения в словаре.

Python

my_other_dict = {«one»:1, «two»:2, «three»:3}

print(my_other_dict) # 1

my_dict = {«name»:»Mike», «address»:»123 Happy Way»}
print(my_dict) # ‘Mike’

В первом примере, мы использовали словарь из предыдущего примере, и вытащили значение, связанное с ключом под названием one. Второй пример демонстрирует, как задавать значение ключу name. Теперь попробуем узнать, находится ли ключ в словаре или нет:

Python

print(«name» in my_dict) # True

print(«state» in my_dict) # False

Что-ж, если ключ в словаре, Python выдает нам Boolean True. В противном случае, мы получаем Boolean False. Если вам нужно получить список ключей  в словаре, вам нужно сделать следующее:

Python

print(my_dict.keys()) # dict_keys()

В Python 2, метод keys дает нам список. Но в Python 3 он дает объект view. Это дает разработчику возможность обновлять словарь, так что view также обновится

Обратите внимание на то, что когда мы используем ключевое слово in для текста содержимого словаря, лучше будет сделать это в словаре, а не в списке, выдаваемом методом keys. Смотрим ниже:

Python

if «name» in my_dict # Такая конструкция правильная

if «name» in my_dict.keys() # Работает но медленее

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

Целые числа (int)

Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:

Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).

>>> 255 + 34
289
>>> 5 * 2
10
>>> 20  3
6.666666666666667
>>> 20 // 3
6
>>> 20 % 3
2
>>> 3 ** 4
81
>>> pow(3, 4)
81
>>> pow(3, 4, 27)
>>> 3 ** 150
369988485035126972924700782451696644186473100389722973815184405301748249

Битовые операции

Над целыми числами также можно производить битовые операции

Дополнительные методы

int.bit_length() — количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

int.to_bytes(length, byteorder, *, signed=False) — возвращает строку байтов, представляющих это число.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
b'\xe8\x03'

classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращает число из данной строки байтов.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes(, byteorder='big')
16711680

Дополнение 1: Как вызывать магические методы

Преобразование типов чисел Python

Мы можем преобразовать int в float с помощью функции float(). Точно так же мы можем использовать функцию int() для преобразования числа с плавающей запятой в int.

Мы можем использовать функцию complex() для преобразования int или float в комплексное число, мнимая часть будет 0j.

Мы не можем преобразовать комплексное число в int или float.

i = 10
f = 10.55

# int to float conversion
f1 = float(i)
print(f1)
print(type(f1))

# float to int conversion
i1 = int(f)
print(i1)
print(type(i1))

# int and float to complex number conversion
c = complex(i)
print(c)
print(type(c))

c = complex(f)
print(c)
print(type(c))

Вывод:

10.0
<class 'float'>
10
<class 'int'>
(10+0j)
<class 'complex'>
(10.55+0j)
<class 'complex'>

Поиск подстроки

Перед выполнением любой задачи по очистке мы должны определить, действительно ли она нужна. В большинстве случаев вопрос сводится к поиску какого-либо символа или фразы в тексте. Python предоставляет множество функций для наших целей.

Заканчивается ли строка указанной подстрокой:

test_string.endswith('dog')
Out: True

Начинается ли строка с указанной подстроки:

test_string.startswith('dog')
Out: False

Содержит ли строка указанную подстроку:

'fox' in test_string
Out: True

Получение индекса подстроки:

test_string.find('fox')
Out: 16

Конечно, любую задачу можно решить множеством способов, особенно если мы говорим о Python. Однако мы думаем, что наше видение синтаксического анализа строк будет для вас полезным.

Проверяет, что все элементы в последовательности True.

Описание:

Функция возвращает значение , если все элементы в итерируемом объекте — истинны, в противном случае она возвращает значение .

Если передаваемая последовательность пуста, то функция также возвращает .

Функция применяется для проверки на ВСЕХ значений в последовательности и эквивалентна следующему коду:

def all(iterable):
    for element in iterable
        if not element
            return False
    return True

Так же смотрите встроенную функцию

В основном функция применяется в сочетании с оператором ветвления программы . Работу функции можно сравнить с оператором в Python, только работает с последовательностями:

>>> True and True and True
# True
>>> True and False and True
# False

>>> all()
# True
>>> all()
# False

Но между и в Python есть два основных различия:

• Синтаксис.
• Возвращаемое значение.

Функция всегда возвращает или (значение )

>>> all()
# True
>>> all(])
# False

Если в выражении все значения , то оператор возвращает ПЕРВОЕ истинное значение, а если все значения , то последнее ложное значение. А если в выражении присутствует значение , то ПЕРВОЕ ложное значение. Что бы добиться поведения как у функции , необходимо выражение с оператором обернуть в функцию .

>>> 3 and 1 and 2 and 6
# 6
>>> 3 and  and 3 and []
# 0

>>> bool(3 and 1 and 2 and 6)
# True
>>> bool(3 and  and 3 and [])
# False

Из всего сказанного можно сделать вывод, что для успешного использования функции необходимо в нее передавать последовательность, полученную в результате каких то вычислений/сравнений, элементы которого будут оцениваться как или . Это можно достичь применяя функцию или выражения-генераторы списков, используя в них встроенные функции или методы, возвращающие значения, операции сравнения, оператор вхождения и оператор идентичности .

num = 1, 2.0, 3.1, 4, 5, 6, 7.9
# использование встроенных функций или
# методов на примере 'isdigit()'
>>> str(x).isdigit() for x in num
# 

# использование операции сравнения
>>> x > 4 for x in num
# 

# использование оператора вхождения `in`
>>> '.' in str(x) for x in num
# 

# использование оператора идентичности `is`
>>> type(x) is int for x in num
# 

# использование функции map()
>>> list(map(lambda x x > 1, num))
False, True, True, True, True, True, True

Примеры проводимых проверок функцией .

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

>>> num1 = range(1, 9)
>>> num2 = range(-1, 7)
>>> all()
# True
>>> all()
# False

Или проверить, что последовательность чисел содержит только ЦЕЛЫЕ числа.

>>> num1 = 1, 2, 3, 4, 5, 6, 7
>>> num2 = 1, 2.0, 3.1, 4, 5, 6, 7.9
>>> all()
# True
>>> all()
# False

Или есть строка с числами, записанными через запятую и нам необходимо убедится, что в строке действительно записаны только цифры. Для этого, сначала надо разбить строку на список строк по разделителю и проверить каждый элемент полученного списка на десятичное число методом . Что бы учесть правила записи десятичных чисел будем убирать точку перед проверкой строки на десятичное число.

>>> line1 = "1, 2, 3, 9.9, 15.1, 7"
>>> line2 = "1, 2, 3, 9.9, 15.1, 7, девять"
>>> all()
# True
>>> all()
# False

Еще пример со строкой. Допустим нам необходимо узнать, есть ли в строке наличие открытой И закрытой скобки?