Форматирование строк
Часто форматирование строк связано с их выводом на экран. Однако следует помнить, что на вывод передается уже сформированная строка. Создание строки, то есть вставка в нее данных в заданных форматах, является отдельной операцией. Готовая строка может быть, например, присвоена переменной, а не выводиться сразу на экран.
% — оператор форматирования строки
Оператор % по отношению к строкам выполняет операцию форматирования и вставки таким образом, что объект, стоящий справа от него, встраивается согласно определенным правилам в строку слева от него:
Такой способ форматирования считается старым потому, что заимствован из функции printf языка C, а в Python кроме него появились другие способы вставки данных в «строки-шаблоны». Однако в ряде случаев удобнее использовать оператор % .
Вывод вещественного числа с заданной точностью
Оператор деления / возвращает вещественное число. Если количество знаков после запятой бесконечно, интерпретатор Python выведит его с большим количеством знаков в дробной части:
a = 4 / 3 print(a)1.3333333333333333 С помощью оператора форматирования строки % можно выполнить округление числа до требуемой точности. Например, оставить только два знака после запятой. Для этого внутри строки, то есть в кавычках, записывают комбинацию символов, которая начинается со знака % . Далее ставят точку. Число после точки обозначает количество знаков после запятой. Символ f обозначает вещественный тип данных float .
a = 4 / 3 print('%.2f' % a)Обратите внимание, переменная a содержит число с большим количеством знаков в дробной части. Строка ‘1.33’ является результатом выполнения выражения ‘%.2f’ % a . Функции print() передается готовая строка ‘1.33’ . Предварительно эту строку можно было бы присвоить отдельной переменной:
a = 4 / 3 b = '%.2f' % a print(b) С другой стороны, по правую сторону от оператора форматирования строки не обязательно указывать переменную. Чаще здесь записывают непосредственно выражение. При этом берут его в скобки.
print('%.2f' % (4 / 3))Строка, содержащая в себе спецификаторы преобразования, также может содержать обычные символы:
print('A = %.1f, B = %d' % (3, 4))A = 3.0, B = 4Символ d в формате вставки обозначает целое число (тип int ).
Оператор форматирования строк выполняет округление вещественных чисел, а не простое отбрасывание «лишних» цифр:
print('%.2f, %.2f' % (0.123, 0.126))0.12, 0.13Вывод символа
Чтобы получить любой символ из таблицы Unicode, в спецификаторе используют букву c , при этом после знака оператора форматирования указывают код требуемого символа.
print('%c' % 189) print('%c' % 32400)Вставка в строку значений словаря через ключи
ab = print('%(good)s, %(price).2f' % ab)AB, 2.30 Вывод данных в поля заданной ширины
Бывает данные надо вывести в виде таблицы. Это значит, что каждый элемент данных выводится в поле определенной ширины, которая измеряется в знакоместах.
Например, вместо подобного вывода:
First 483 1.1 Second 9 10.7 First 483 1.1 Second 9 10.7 Для таких случаев в формате вставки элемента данных в строку указывается ширина поля (количество знакомест). Делается это сразу после знака процента.
print('%-7s %5d %8.1f' % ('First', 483, 1.1)) print('%-7s %5d %8.1f' % ('Second', 9, 10.65))Знак «минус» заставляет данные выравниваться по левому краю. По умолчанию они выравниваются по правому:
print('%7s %5d' % ('First', 483)) print('%7s %5d' % ('Second', 9)) First 483 Second 9
Строковый метод format
Строковый метод format вставляет переданные в него аргументы в строку, к которой применяется. В строке места вставки, или «поля замены», определяются фигурными скобками. Внутри скобок могут указываться индексы или ключи аргументов, переданных в метод format.
print("<>, <> and <>".format('A', 8, 'B')) print(", and ".format('A', 8, 'B'))A, 8 and B 8, A and B В format() может передоваться больше аргументов, чем имеется мест вставок в строке. В таком случае оставшиеся аргументы игнорируются.
nums = ['I', 'II', 'III', 'IV', 'V'] print("<> <> <>".format(*nums)) print(" ".format(*nums))I II III I V Вставка значений по ключу:
print(' = '.format(var='pi', value=3.14))pi = 3.14 u = print('-'.format(**u)) print(''.format(**u)) print('-'.format('John', **u))Bob-35 Bob John-35Вывод атрибутов объекта:
class House: size = 5 street = "Red" h = House() print(', '.format(h))5, Red Метод format позволяет задавать ширину поля и выравнивание:
u = print('--'.format(**u)) print('10>-4>-'.format(**u)) print('--'.format(**u))Bob - 35- Bob- 35- Bob - 35 - Вывод вещественных чисел:
print('<>'.format(4/3)) print(''.format(4/3)) print(''.format(4/3)) print(''.format(4/3)) print(''.format(4/3))1.3333333333333333 1.333333 1.33 1.33 1.333333e+00 Форматированные строковые литералы
В последних версиях Python появилась возможность использовать так называемые форматированные строковые литералы (formatted string literals). В отличие от обычных строковых литералов перед f-строками ставится буква f .
В теле строки могут находиться включения в фигурных скобках. В процессе выполнения программы интерпретатор исполняет выражения в фигурных скобках, вставляя их результат в соответстующие места строки.
user = input() print(f'Hello !') a = 4.5678 print(f'Result ')Bob Hello Bob! Result 4.57 print(f'Hello !') a = 4 b = 3 print(f'Result ')John Hello John! Result 1.33 Выравнивание строк другими строковыми методами
a = "Hello" print('|', a.center(10), '|') print(a.rjust(14)) print(a.ljust(10)) print(a.ljust(14, '.')) print(a.center(14, '.'))| Hello | Hello Hello Hello. . Hello. Как вывести print в одну строку python
-
Передать функции print() несколько аргументов. Например:
print('string1', 'string2') # => string1 string2 print('string1', end='') print('string2') # => string1string2 5++ способов в одну строку на Python решить первую задачу Проекта Эйлера
Однажды меня посетила мысль, а что если попробовать решить первую задачу Проекта Эйлера всевозможными способами, но с условием, что решение должно быть в одну строку. В итоге получилось более пяти однострочных решений с применением Filter, Map, Reduce, Generator Expression и т.д. В этой статье я покажу то, к чему я пришёл.
Это моя первая статья. Стоит отнестись к ней настороженно. Уникальные решения будут оформлены в отдельные пункты. Менее уникальные — в подпункты.
Условие задачи
Если выписать все натуральные числа меньше 10, кратные 3 или 5, то получим 3, 5, 6 и 9. Сумма этих чисел равна 23.
Найдите сумму всех чисел меньше 1000, кратных 3 или 5.
00 — Базовое решение
Прежде чем перейти непосредственно к однострочным решениям, разумно было бы упомянуть сначала стандартное, классическое решение:
result = 0 for i in range(1, 1000): if i%3 == 0 or i%5 == 0: result += i print(result) # => 233168Перебираем последовательность чисел от 1 до 999. Если перебираемое число делится на 3 или на 5 без остатка от деления, то прибавляем каждое такое число в заранее объявленную переменную result .
01 — Generator Expression. Выражение-генератор
print(sum(i for i in range(1, 1000) if i%3 == 0 or i%5 == 0)) # => 233168Числа из последовательности от 1 до 999, делящиеся на 3 или на 5 без остатка от деления, собираются в генератор. Затем функция sum() складывает содержимое генератора.
01.a — List Comprehension. Выражение на основе списка
print(sum([i for i in range(1, 1000) if i%3 == 0 or i%5 == 0])) # => 233168В отличии от предыдущего, здесь выражение дополнительно помещается в список. Стоило упомянуть этот вариант, так как он довольно часто встречается в различных статьях.
01.b — Set Comprehension. Выражение на основе множества
print(sum()) # => 233168Тоже, что и в предыдущем, но вместо списка здесь множество.
02 — Filter
print(sum(filter(lambda i: i%3 == 0 or i%5 == 0, range(1, 1000)))) # => 233168Функция filter схожа по принципу работы с выражением-генератором. Функция лямбда применяется к каждому элементу последовательности чисел от 1 до 999. Все числа последовательности, делящиеся на 3 или на 5 без остатка от деления, возвращаются, затем суммируются функцией sum() .
03 — Map
print(sum(map(lambda i: i if i%3 == 0 or i%5 == 0 else 0, range(1, 1000)))) # => 233168Перебираемые числа последовательности от 1 до 999, делящиеся на 3 или 5 без остатка от деления, остаются без изменений, все остальные числа заменяются на ноль. Полученная последовательность суммируется функцией sum() .
04 — Reduce
from functools import reduce print(reduce(lambda x, y: x+y if y%3 == 0 or y%5 == 0 else x, range(1, 1000), 0)) # => 233168Из всей подборки, этот вариант «очень не очень». Как по степени реализации, так и по времени выполнения(но об этом попозже).
Если в reduce указан инициализатор(в нашем случае ноль), то он становится накопителем. К нему по очереди прибавляются только те числа из последовательности от 1 до 999, которые делятся на 3 или на 5 без остатка от деления. Если из функции reduce убрать инициализатор ноль, то инициализатором станет крайний левый элемент последовательности.
05 — Однострочное решение на основе множества
print(sum(set(range(3, 1000, 3)) | set(range(5, 1000, 5)))) # => 233168Самое элегантное решение, как по красоте написания, так и по времени выполнения.
Последовательность чисел от 1 до 999, кратную трём, помещаем во множество и объединяем со множеством, содержащим в себе последовательность чисел от 1 до 999, кратную пяти. Содержимое, полученного множества суммируем функцией sum() .
05.a — Ещё одно однострочное решение на основе множества
print(sum( <*range(3, 1000, 3)>| <*range(5, 1000, 5)>)) # => 233168Похожий вариант на предыдущий, но, если использовать фигурные скобки, то последовательность чисел от 1 до 999, кратную трём и последовательность чисел от 1 до 999, кратную пяти, нужно распаковывать.
05.b — И ещё одно однострочное решение на основе множества
print(sum(set(range(3, 1000, 3)).union(range(5, 1000, 5)))) # => 233168Создаём множество, с последовательностью чисел от 1 до 999, кратную трём и присоединяем к нему последовательность чисел от 1 до 999, кратную пяти. Затем функцией sum() суммируем.
05.c И последнее однострочное решение на основе множества
print(sum(set([*range(3, 1000, 3)] + [*range(5, 1000, 5)]))) # => 233168По аналогии с предыдущими. Распаковываем последовательности чисел в списки. Складываем списки. Оборачиваем во множество. Затем суммируем функцией sum() .
Смотрим на скорость выполнения каждого однострочного решения
Если проверить скорость выполнения каждого однострочного решения в командной строке, при помощи timeit, получим следующие значения в микросекундах:
sum(i for i in range(1, 1000) if i%3 == 0 or i%5 == 0) # 203 usec sum([i for i in range(1, 1000) if i%3 == 0 or i%5 == 0]) # 181 usec sum() # 189 usec sum(filter(lambda i: i%3 == 0 or i%5 == 0, range(1, 1000))) # 306 usec sum(map(lambda i: i if i%3 == 0 or i%5 == 0 else 0, range(1, 1000))) # 313 usec reduce(lambda x, y: x+y if y%3 == 0 or y%5 == 0 else x, range(1, 1000), 0)# 324 usec sum(set(range(3, 1000, 3)) | set(range(5, 1000, 5))) # 47 usec sum( <*range(3, 1000, 3)>| <*range(5, 1000, 5)>) # 47 usec sum(set(range(3, 1000, 3)).union(range(5, 1000, 5))) # 41 usec sum(set([*range(3, 1000, 3)] + [*range(5, 1000, 5)])) # 43 usecМетодика расчёта: python -m timeit «выражение»
Быстрее всего справились с задачей последние четыре варианта.
Заключение
Всего получилось 5 уникальных + 5 не уникальных решений. Благодаря этой задаче у меня появилось более устойчивое понимание работы функций Filter, Map, Reduce. И если раньше я недоумевал, почему функцию Reduce убрали из основного модуля, то теперь я не сомневаюсь в правильности этого решения.
В статье я старался отойти от популярного шаблона повествования «точность на грани бесполезности». Где предложения набиты под завязку «тяжёлыми» терминами, а из знакомого там только союзы и предлоги. Не уверен, что у меня получилось.
ПРЕОБРАЗОВАНИЕ ТИПОВ ДАННЫХ В PYTHON
С помощью функции complex() удобно формировать комплексные числа, указывая через запятую два аргумента: действительную часть и мнимую часть.
a = complex(3.2, 1.5) print(a) (3.2+1.5j) Смешанная арифметика
Python поддерживает смешанную арифметику в выражениях, состоящих из чисел разных типов. При этом целочисленный тип (int) при необходимости расширяется до дробного (float), а дробный — до комплексного (complex). То же самое происходит при сравнении чисел разного типа.
Системы счисления
Для преобразования чисел в двоичную, восьмиричную и шестнадцатиричную систему служат функции bin(), oct() и hex(). Эти функции возвращают строковые представления чисел, что необходимо учитывать при работе с ними.
a = hex(38) print(a) 0x26 Преобразовать строковое представление недесятичного числа в десятичную систему можно с помощью функции int(), указав вторым аргументом основание системы счисления (от 2 до 36 включительно).
a = '0x26' b = int(a, base=16) print(b) Округление
Для округления чисел с плавающей точкой используется функция round(). Функция использует банковское округление (по Гауссу) до ближайшего чётного целого, чтобы избежать серийного накопления погрешности. Например, round(1.5) + round(2.5) будет равен 4. При обычном математическом округлении сумма округленных чисел будет равна 5.
С помощью второго аргумента функции round() можно округлить число до заданного количества знаков после запятой. Если воторой аргумент не задан, то число округляется до целого.
a = round(1.5) print(a) b = round(2.5) print(b) c = round(6.4567, 2) print(c) d = round(4.35, 1) print(d) e = round(4.45, 1) print(e) 2 2 6.46 4.7 4.5 Преобразование в строку
Для преобразования в строку используется функция str(). Аргументом функции str() может выступать число, строка, кортеж, список, множество, словарь, логическое значение, None.
Любой объект, преобразованный в строку, становится просто набором символов.
a = 5.3 x = str(a) print(x, type(a), type(x)) Преобразование в список
Для преобразования в список используется функция list(). Аргументом функции list() может выступать любой итерируемый тип данных (строка, кортеж, список, множество, словарь).
При преобразовании строки в список, мы получаем список, состоящий из символов строки.
Стоит обратить внимание на то, что при преобразовании словаря в список, в списке оказываются только ключи.
b = 'Python' x = list(b) print(x) c = (3, 4) x = list(c) print(x) d = [5, 6] x = list(d) print(x) e = x = list(e) print(x) f = x = list(f) print(x) ['P', 'y', 't', 'h', 'o', 'n'] [3, 4] [5, 6] [8, 7] [1, 2] Преобразование в кортеж
Для преобразования в кортеж используется функция tuple(). Аргументом функции tuple() может выступать любой итерируемый тип данных (строка, кортеж, список, множество, словарь).
Преобразование в кортеж происходит по тому же принципу, по которому происходит преобразование в список.
Преобразование в множество
Для преобразования в множество используется функция set(). Аргументом функции set() может выступать любой итерируемый тип данных (строка, кортеж, список, множество, словарь).
Преобразование в множество происходит по тому же принципу, по которому происходит преобразование в список, но следует учитывать, что повторяющиеся элементы в множестве будут представлены только один раз.
a = [5, 6, 5, 6, 7] x = set(a) print(x) С помощью последовательного преобразования числа в строку, а затем в множество, можно найти набор символов, которые встречаются в числе.
a = 227 x = set(str(a)) print(x) Преобразование в словарь
Для преобразования в словарь используется функция dict().
Для преобразования в словарь каждый элемент преобразуемой последовательности должен быть парой. Первым элементом в паре может быть любой неизменяемый тип данных (число, строка, кортеж), а вторым — любой тип данных.
f = [[1, 'яблоко'], [2, 'тыква']] x = dict(f) print(x) Преобразование в логический тип
Для преобразования в логический тип используется функция bool().
Функция bool() вернет False, если в качестве аргумента выступает пустая строка, нулевое число, None, пустой список, пустой кортеж или пустое множество. Непустая строка, ненулевое число, даже если оно отрицательное, вернут True. Непустое множество, непустой список или непустой кортеж, даже если они содержат один пустой элемент, вернут True.
a = -7 x = bool(a) print(x) b = '' x = bool(b) print(x) c = x = bool(c) print(x) True False True