Что является концом блока или набора инструкций в python

Содержание

Регистр имен переменных имеет значение.

Конец строки является концом инструкции (точка с запятой не требуется).

Вложенные инструкции объединяются в блоки по величине отступов. Отступ может
быть любым, главное, чтобы в пределах одного вложенного блока отступ был одинаков. Отступ в 1 пробел не лучшее решение. Используйте 4 пробела. Причем смешивать нельзя — это не равно nhb пробела и знак табуляции, например (визуально может выглядеть одинаково).

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

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

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

Если после двоеточия один оператор, то можно писать в одну строку:

if x > y: print(x)

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

>>> 'XXX'    'YYY'
'XXXYYY'

Конец строки для интерпретатора означает конец инструкции, но только в том случае если конец строки не находится внутри: круглых (), квадратных [] и фигурных {} скобок, а так же тройных кавычках или тройных апострофах. Это удобно, если нам необходимо вводить длинные последовательности, например матрица 6×6 может быть введена вот так:

>>> mat = [[0, 0, 0, 0, 0, 0],
...        [1, 1, 1, 1, 1, 1],
...        [2, 2, 2, 2, 2, 2],
...        [3, 3, 3, 3, 3, 3],
...        [4, 4, 4, 4, 4, 4],
...        [5, 5, 5, 5, 5, 5]]

Но для одинарных кавычек или апострофов этот способ не не подойдет. Нужно использовать символ «» для склеивания нескольких строк в один оператор

>>> s = 'Это очень длинная строка, которая не может ' + 
... 'содержать символы переноса - "\n", и можно ' + 
... 'подумать, что в програмном коде она должна ' + 
... 'храниться именно в таком виде. Но ' + 
... 'на самом деле это не так.'

или круглые скобки (рекомендуемый способ):

>>> s = ('Это очень длинная строка, которая не может '
...      'содержать символы переноса - "\n", и можно '
...      'подумать, что в програмном коде она должна '
...      'храниться именно в таком виде. Но '
...      'на самом деле это не так.')

этот способ допускает комментирование:

>>> s = ('|login'     #  логин
...      '|pas'       #  пароль
...      '|hash|'     #  хеш
... )
>>> 
>>> s
'|login|pas|hash|'
>>>

Запятая не является оператором в Python.

>>> "a" in "b", "a"
(False, 'a')

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

("a" in "b"), "a"
# А не
"a" in ("b", "a")

То же самое верно и для операторов присваивания (=, += и другие).
Они не являются операторами как таковыми, а лишь синтаксическими разделителями в операциях присваивания.

Однострочный #

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

'''
коммент
'''

такой строковый литерал не должен содержать внутри символов '''.

Строковые литералы, заключенные в тройные кавычки, могут содержать:

• кавычки («)

• апострофы (‘)

• docstring комментарии («»»func desc»»»)

• переводы строк

В тоже время руководство по стилю кода (pep-8) рекомендует использовать # для блочных комментариев.

В PyCharm можно выделить блок который нужно закомментировать и нажать Ctrl+/

PyCharm в начале каждой строки поставит ‘#’ или уберет

import math
a = 10
b = 20
print(math.sqrt(a*a + b*b))

Python Built-in Functions w3schools

• abs(x) — Возвращает абсолютную величину (модуль числа).

• all(последовательность) — Возвращает True, если все элементы истинные (или, если последовательность пуста).

• any(последовательность) — Возвращает True, если хотя бы один элемент — истина. Для пустой последовательности возвращает False.

• ascii(object) — Как repr(), возвращает строку, содержащую представление объекта, но заменяет не-ASCII символы на экранированные последовательности.

• bin(x) — Преобразование целого числа в двоичную строку.

• callable(x) — Возвращает True для объекта, поддерживающего вызов (как функции).

• chr(x) — Возвращает односимвольную строку, код символа которой равен x.

• classmethod(x) — Представляет указанную функцию методом класса.

• compile(source, filename, mode, flags=0, dont_inherit=False) — Компиляция в программный код, который впоследствии может выполниться функцией eval или exec. Строка не должна содержать символов возврата каретки или нулевые байты.

• delattr(object, name) — Удаляет атрибут с именем ‘name’.

• dir([object]) — Список имен объекта, а если объект не указан, список имен в текущей локальной области видимости.

• divmod(a, b) — Возвращает частное и остаток от деления a на b.

• enumerate(iterable, start=0) — Возвращает итератор, при каждом проходе предоставляющем кортеж из номера и соответствующего члена последовательности.

• eval(expression, globals=None, locals=None) — Выполняет строку программного кода.

• exec(object[, globals[, locals]]) — Выполняет программный код на Python.

• filter(function, iterable) — Возвращает итератор из тех элементов, для которых function возвращает истину.

• format(value[,format_spec]) — Форматирование (обычно форматирование строки).

• getattr(object, name ,[default]) — извлекает атрибут объекта или default.

• globals() — Словарь глобальных имен.

• hasattr(object, name) — Имеет ли объект атрибут с именем ‘name’.

• hash(x) — Возвращает хеш указанного объекта.

• help([object]) — Вызов встроенной справочной системы.

• hex(х) — Преобразование целого числа в шестнадцатеричную строку.

• id(object) — Возвращает “адрес” объекта. Это целое число, которое гарантированно будет уникальным и постоянным для данного объекта в течение срока его существования.

• input([prompt]) — Возвращает введенную пользователем строку. Prompt — подсказка пользователю.

• isinstance(object, ClassInfo) — Истина, если объект является экземпляром ClassInfo или его подклассом. Если объект не является объектом данного типа, функция всегда возвращает ложь.

• issubclass(класс, ClassInfo) — Истина, если класс является подклассом ClassInfo. Класс считается подклассом себя.

• iter(x) — Возвращает объект итератора.

• len(x) — Возвращает число элементов в указанном объекте (строке, списке).

• locals() — Словарь локальных имен.

• map(function, iterator) — Итератор, получившийся после применения к каждому элементу последовательности функции function.

• max(iter, [args …] * [, key]) — Максимальный элемент последовательности.

• min(iter, [args …] * [, key]) — Минимальный элемент последовательности.

• next(x) — Возвращает следующий элемент итератора.

• oct(х) — Преобразование целого числа в восьмеричную строку.

• open(file, mode=’r’, buffering=None, encoding=None, errors=None, newline=None, closefd=True) — Открывает файл и возвращает соответствующий поток.

• ord(с) — Код символа.

• pow(x, y[, r]) — ( x ** y ) % r.

• reversed(object) — Итератор из развернутого объекта.

• repr(obj) — Представление объекта.

• print([object, …], *, sep=” ”, end=’n’, file=sys.stdout) — Печать.

• property(fget=None, fset=None, fdel=None, doc=None)

• round(X [, N]) — Округление до N знаков после запятой.

• setattr(объект, имя, значение) — Устанавливает атрибут объекта.

• sorted(iterable[, key][, reverse]) — Отсортированный список.

• staticmethod(function) — Статический метод для функции.

• sum(iter, start=0) — Сумма членов последовательности.

• super([тип [, объект или тип]]) — Доступ к родительскому классу.

• type(object) — Возвращает тип объекта.

• type(name, bases, dict) — Возвращает новый экземпляр класса name.

• vars([object]) — Словарь из атрибутов объекта. По умолчанию — словарь локальных имен.

• zip(*iters) — Итератор, возвращающий кортежи, состоящие из соответствующих элементов аргументов-последовательностей.

Все данные в Python представлены объектами. Имена являются лишь ссылками на эти объекты и не несут нагрузки по декларации типа.

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

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

int, long, bool, float, complex, str, unicode, кортеж tuple, список list, словарь dict, файлы file, вспомогательные типы buffer, slice

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

Встроенные функции, выполняющие преобразование типов

• bool(x) — преобразование к типу bool

• bytearray([источник [, кодировка [ошибки]]]) — преобразование к bytearray. Bytearray — изменяемая последовательность целых чисел в диапазоне 0<=X<256. Вызванная без аргументов, возвращает пустой массив байт.

• bytes([источник [, кодировка [ошибки]]]) — возвращает объект типа bytes, который является неизменяемой последовательностью целых чисел в диапазоне 0<=X<256.

• complex([real[, imag]]) — преобразование к комплексному числу.

• dict([object]) — преобразование к словарю.

• float([X]) — преобразование к числу с плавающей точкой.

• frozenset([последовательность]) — возвращает неизменяемое множество.

• int([object], [основание системы счисления]) — преобразование к целому числу.

• list([object]) — создает список.

• memoryview([object]) — создает объект memoryview.

• object() — возвращает безликий объект, являющийся базовым для всех объектов.

• range([start=0], stop, [step=1]) — арифметическая прогрессия от start до stop с шагом step.

• set([object]) — создает множество.

• slice([start=0], stop, [step=1]) — объект среза от start до stop с шагом step.

• str([object], [кодировка], [ошибки]) — строковое представление объекта. Использует метод str.

• tuple(obj) — преобразование к кортежу.

True, False

операторы and, or, not

a = 10 # присвоение
b = 20
c = 30
a == b # False (сравнение)
a != b # True
a < b < c # True
if not y == 1: # отрицание
a != b and a != c # логическое И

В языке Python логическое значение несет каждый объект: нули, пустые строки и последовательности, специальный объект None и логический литерал False имеют значение «ложь», а прочие объекты значение «истина». Для обозначения истины обычно используется 1 или True.

Проверка истинности в Python

• Любое число, не равное 0, или непустой объект — истина.

• Числа, равные 0, пустые объекты и значение None — ложь

• Операции сравнения применяются к структурам данных рекурсивно

• Операции сравнения возвращают True или False

• Логические операторы and и or возвращают истинный или ложный объект-операнд

a=10
b=20
c=15
print(a<b>c) # True

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

• int([object], [основание системы счисления]) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно. Пример >>> int(‘0b10011’, 2) результат 19

• bin(x) — преобразование целого числа в двоичную строку. >>> hex(19) результат ‘0x13’

• hex(х) — преобразование целого числа в шестнадцатеричную строку.

Вещественные числа — float

Для высокой точности используют другие объекты (например Decimal и Fraction).

вещественные числа не поддерживают длинную арифметику

• round(number[, ndigits]) — Округление. If ndigits опущено, то до ближайшего целого

  • round(0.5) and round(-0.5) are 0, and round(1.5) is 2 — банковское округление

  • round(12345.6789,-3) результат 12000.0

• float.as_integer_ratio() — пара целых чисел, чьё отношение равно этому числу.

• float.is_integer() — является ли значение целым числом.

• float.hex() — переводит float в hex (шестнадцатеричную систему счисления).

см import math, random

Комплексные числа — complex — модуль cmath.

Python String Methods

a = input("Введите имя одного из трех мушкетеров: ")
a = a.lower()

Могут быть в одинарных и в двойных кавычках. Разницы между двойными и одинарными кавычками нет.
Двойные кавычки можно писать внутри одинарных. Одинарные можно писать внутри двойных.

t – символ табуляции, n новая строка и т.д.

Тем не менее если вам нужно использовать внутри строки кавычки или апострофы, то лучше экранировать их специальным символом

Символ в конце строки позволяет разбить в коде одну строчку на несколько.

Для строк, включающих перевод строки, используется по 3 кавычки в начале и в конце:

st = '''Список покупок:
- молоко
- огурцы
- селёдка'''
print(st)
 
"""abc"""    # тоже тройные кавычки

Внутри тройных можно писать любые. Двойные внутри двойных кавычек надо экранировать («).

Длина строки: print(len(name))

Вывод подстроки (среза) [0:4], правая граница не включается. По умолчанию первый индекс равен 0, а второй — длине строки.

name = 'Автомобиль'
print(name[1]) # выведет в
print(name[0:4]) # выведет Авто
print(name[-3]) # выведет и
print(name[:]) # выведет Автомобиль
print(name[1:]) # выведет втомобиль
print(name[2:-2]) # выведет томоби
print(name[::-1]) # ьлибомотвА
print(name[3:6:-1]) # пустая строка
print(name[6:3:-1]) # бом
print(name[2::2]) # тмбл

Отсчет начинается с 0. Отрицательный индекс — отсчет с конца строки, начиная с -1

можно задать шаг, с которым нужно извлекать срез, -1 — обратный порядок

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

Ошибка:
s = 'spam'
s[1] = 'b'
Правильно:
s = s[0] + 'b' + s[2:]

Поиск по строке find

name = 'Автомобиль'
print(name.find('мобиль')) # выведет 4

Вернет индекс первой буквы, если найдено или -1, если не найдено

Замена подстроки replace

name = 'Автомобиль'
name = name.replace('мобиль', 'мат')
print(name) # выведет Автомат

r — «Сырые» строки — подавляют экранирование. Если перед открывающей кавычкой стоит символ ‘r’ (в любом регистре), то механизм экранирования отключается.

S = r'C:newt.txt'

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

r'D:\мои документыкниги' 

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

Можно добавить экранированный символ обратного слеша \ вручную:

>>> s = r'D:\мои документыкниги' + '\'

Сырые строки исп для хранения путей, кода LATEX (содержит обратные слеши)

u — Юникод

u'world'    #  строки юникода

существует лишь для совместимости строк в коде Python3 и Python2. Так что если вы имеете дело только с Python3, то можете смело забыть об этом префиксе.

строки байтов, каждый байт — число от 0 до 255, либо обычный символ

b'x77x6fx72x6cx64' #'world'

f — форматируемая строка. В Python, начиная с версии 3.6, появился новый префикс f, который позволяет определить строку как форматируемую. см. str.format() — метод форматирования строк

fr — форматируемая сырая строка

>>> f'коэффициент k = {7.143827:0=+10.4}'
'коэффициент k = +00007.144'

Знак = означает, что если значение короче чем ширина поля, то оно должно быть дополнено слева до нужной ширины тем символом, который указан слева от =, в нашем случае этот символ 0. Далее, после знака = указан символ +, который вынуждает обозначать положительные и отрицательные числа соответствующими знаками: + или -. Далее, перед . указано число 10 – это ширина поля. А вот число после точки указывает точность (ширину дробной части вместе с точкой) представления вещественного числа.

Например, формирование путей к файлам:

>>> dir_name = 'my_doc'
>>> file_name = 'data.txt'
>>> 
>>> fr'home{dir_name}{file_name}'
'home\my_doc\data.txt'

Built-in Types — Python 3.8.9 documentation

• S1 + S2 Конкатенация строк

• S1 * 3 — Повторение строки

• S[i] — Обращение по индекс

• S[i:j:step] Извлечение среза

• len(S) Длина строки

• S.find(str, [start], [end]) Поиск подстроки в строке. Возвращает номер первого вхождения или -1

• S.rfind(str, [start], [end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или -1

• S.index(str, [start], [end]) Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError

• S.rindex(str, [start], [end]) Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError

• S.replace(шаблон, замена) Замена

• S.split(символ) Разбиение строки по разделителю. Если разделитель не указать, то разделителем будет считать все пробельные символы (пробел, n, t), пустых строк в результате не будет

• s.rsplit

print('1,2,3'.split(','))          # ['1', '2', '3']
print('1,2,3,4,5,6'.split(',', maxsplit=2)) # ['1','2','3,4,5,6']
print('1,2,,3,'.split(','))        # ['1', '2', '', '3', '']
print('1<>2<>3'.split('<>'))       # returns ['1', '2', '3']
print('1 2, 3. 4  '.split())     # returns ['1', '2,', '3.', '4']

• splitlines([keepends]). Чтобы концы строк включались в результат, вызывать с аргументом False. Концом считаются n r f v x1c x1d x1e x85 u2028 Line Separator u2029 Paragraph Separator

print('1,2,3nn5,6'.splitlines())  # ['1,2,3', '', '5,6']
print("One linen".splitlines())    # ['One line']

• S.isdigit() Состоит ли строка из цифр

• S.isalpha() Состоит ли строка из букв

• S.isalnum() Состоит ли строка из цифр или букв

• S.islower() Состоит ли строка из символов в нижнем регистре

• S.isupper() Состоит ли строка из символов в верхнем регистре

• S.isspace() Состоит ли строка из символов (пробел, fnrtv)

• S.istitle() Начинаются ли слова в строке с заглавной буквы

• S.upper() Преобразование строки к верхнему регистру

• S.lower() Преобразование строки к нижнему регистру

• S.startswith(str) Начинается ли строка S с шаблона str

• S.endswith(str) Заканчивается ли строка S шаблоном str

• ord(символ) Символ в его код ASCII

• chr(число) Код ASCII в символ

• S.capitalize() Переводит первый символ строки в верхний регистр, а все остальные в нижний

• S.center(width, [fill]) Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)

• S.expandtabs([tabsize]) Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам

• S.lstrip([chars]) Удаление пробельных символов в начале строки, или указанных символов, в любой последовательности

• S.rstrip([chars]) Удаление пробельных или указанных символов в конце строки

• S.strip([chars]) Удаление пробельных или указанных символов в начале и в конце строки

• S.swapcase() Переводит символы нижнего регистра в верхний, а верхнего – в нижний

• S.title() Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний

• S.zfill(width) Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

• S.ljust(width, fillchar=’ ‘) Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar

• S.rjust(width, fillchar=’ ‘) Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar

• S.partition(шаблон) Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки

• S.rpartition(sep) Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку

print('Авто/мобиль'.partition('/')) # выведет ('Авто', '/', 'мобиль')

• S.count(str, [start],[end]) Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)

print('Авто/мо/биль'.count('/')) # выведет 2

• S.join(список) Сборка строки из списка с разделителем S

mylist = ["apple", "banana", "cherry"]
print(';'.join(mylist)) # выведет apple;banana;cherry

• S.format(*args, **kwargs) Форматирование строки

неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.

Создать можно:

• с помощью литерала (фигурные скобки)

• с помощью функции dict

• с помощью метода fromkeys

• с помощью генераторов словарей

>>> d = {}
>>> d
{}
>>> d = {'dict': 1, 'dictionary': 2}
>>> d
{'dict': 1, 'dictionary': 2}
 
>>> d = dict(short='dict', long='dictionary')
>>> d
{'short': 'dict', 'long': 'dictionary'}
>>> d = dict([(1, 1), (2, 4)])
>>> d
{1: 1, 2: 4}
 
>>> d = dict.fromkeys(['a', 'b'])
>>> d
{'a': None, 'b': None}
>>> d = dict.fromkeys(['a', 'b'], 100)
>>> d
{'a': 100, 'b': 100}
 
>>> d = {a: a ** 2 for a in range(7)}
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

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

>>> d = {1: 2, 2: 4, 3: 9}
>>> d[1]
2
>>> d[4] = 4**2
>>> d
{1: 2, 2: 4, 3: 9, 4: 16}
>>> d['1']
Traceback (most recent call last):
File "", line 1, in
d['1']
KeyError: '1'

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

• dict.clear() — очищает словарь

• del d[key] — удаляет из списка ключ-значение

• key in d — истина, если словарь d имеет ключ key

• key not in d

• dict.copy() — возвращает копию словаря

• classmethod dict.fromkeys(seq[, value]) — создает словарь с ключами из seq и значением value (по умолчанию None)

• dict.get(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None)

• dict.items() — возвращает пары (ключ, значение)

• dict.keys() — возвращает ключи в словаре

• dict.pop(key[,default]) — удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).

• dict.popitem() — удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.

• dict.setdefault(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ с значением default (по умолчанию None)

• dict.update([other]) — обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

• dict.values() — возвращает значения в словаре.

• dict.iter(d) — Return an iterator over the keys of the dictionary. эквивалентно iter(d.keys())

Changed in version 3.7: Dictionary order is guaranteed to be insertion order.

Множество в python — “контейнер”, содержащий не повторяющиеся элементы в произвольном порядке.

Создать можно:

• с помощью литерала (фигурные скобки) — как словарь

• с помощью функции set

• с помощью генераторов

>>> a = set()
>>> a
set()
>>> a = set('hello')
>>> a
{'h', 'o', 'l', 'e'}
>>> a = {'a', 'b', 'c', 'd'}
>>> a
{'b', 'c', 'a', 'd'}
>>> a = {i ** 2 for i in range(10)} # генератор множеств
>>> a
{0, 1, 4, 81, 64, 9, 16, 49, 25, 36}
>>> a = {} # А так нельзя!
>>> type(a)
<class 'dict'>

set() — пустое множество. Все элементы только по одному разу, порядок не важен.

Множества удобно использовать для удаления повторяющихся элементов:

>>> words = ['hello', 'daddy', 'hello', 'mum']
>>> set(words)
{'hello', 'daddy', 'mum'}

Операции над множествами:

• len(s) — число элементов в множестве (размер множества)

• x in s — принадлежит ли x множеству s

• x not in s — не принадлежит ли x множеству s

• set.isdisjoint(other) — истина, если set и other не имеют общих элементов.

• set == other — все элементы set принадлежат other, все элементы other принадлежат set

• set.issubset(other) или set <= other — все элементы set принадлежат other

• set.issuperset(other) или set >= other — аналогично

• set.union(other, …) или set | other | … — объединение нескольких множеств

• set.intersection(other, …) или set & other & … — пересечение

• set.difference(other, …) или set — other — … — множество из всех элементов set, не принадлежащие ни одному из other

• set.symmetric_difference(other); set ^ other — множество из элементов, встречающихся в одном множестве, но не встречающиеся в обоих

• set.copy() — копия множества

операции, изменяющие множество:

• set.update(other, …); set |= other | … — объединение

• set.intersection_update(other, …); set &= other & … — пересечение

• set.difference_update(other, …); set -= other | … — вычитание.

• set.symmetric_difference_update(other); set ^= other — множество из элементов, встречающихся в одном множестве, но не встречающиеся в обоих

• set.add(elem) — добавляет элемент в множество.

• set.remove(elem) — удаляет элемент из множества. KeyError, если такого элемента не существует

• set.discard(elem) — удаляет элемент, если он находится в множестве.

• set.pop() — удаляет первый элемент из множества. Так как множества не упорядочены, нельзя точно сказать, какой элемент будет первым

• set.clear() — очистка множества

Единственное отличие set от frozenset заключается в том, что set — изменяемый тип данных, а frozenset — нет. Примерно похожая ситуация с списками и кортежами.

Создание с помощью функции frozenset()

>>> a = set('qwerty')
>>> b = frozenset('qwerty')
>>> a == b
True
>>> type(a - b)
<class 'set'>
>>> type(a | b)
<class 'set'>
>>> a.add(1)
>>> b.add(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

x = int(input("Please enter an integer: "))
 
# Повторение строки
x = 'Spam!'
print(x * 8)
 
# вывод без завершающего перехода на новую строку
print(line, end='')
 
# format
if speedRatio >= 10:
 print('Скорость превышена на %s. Ваш штраф %s руб'
 % (speedRatio, fine * speedRatio // 10))

см также функцию format(value, format) и str.format()

• ‘<‘ — Left aligns the result (within the available space)

• ‘>’ — Right aligns the result (within the available space)

• ‘^’ — Center aligns the result (within the available space)

• ‘=’ — Places the sign to the left most position

• ‘+’ — Use a plus sign to indicate if the result is positive or negative

• ‘-‘ — Use a minus sign for negative values only

• ‘ ‘ — Use a leading space for positive numbers

• ‘,’ — Use a comma as a thousand separator

• ‘_’ — Use a underscore as a thousand separator

• ‘b’ — Binary format

• ‘c’ — Converts the value into the corresponding unicode character

• ‘d’ — Decimal format

• ‘e’ — Scientific format, with a lower case e

• ‘E’ — Scientific format, with an upper case E

• ‘f’ — Fix point number format

• ‘F’ — Fix point number format, upper case

• ‘g’ — General format

• ‘G’ — General format (using a upper case E for scientific notations)

• ‘o’ — Octal format

• ‘x’ — Hex format, lower case

• ‘X’ — Hex format, upper case

• ‘n’ — Number format

• ‘%’ — Percentage format

Пример

  print(format(0.5, '%')) # 50.000000%
  print(format(255, 'x')) # ff
 
  # placeholder:
  price = 49 # The price is 49 dollars
  print("The price is {} dollars".format(price))
 
  # два знака после запятой
  txt = "The price is {:.2f} dollars"
  print(txt.format(price)) # The price is 49.00 dollars
 
  # несколько переменных
  myorder = "I want {} pieces of item number {} for {:.2f} dollars."
  print(myorder.format(quantity, itemno, price))
 
  # нумерованные плейсхолдеры, нумерация с 0
  myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
  print(myorder.format(quantity, itemno, price))
  # можно один индекс использовать несколько раз
  age = 36
  name = "John"
  txt = "His name is {1}. {1} is {0} years old."
  print(txt.format(age, name))  
 
  # именованные плейсхолдеры
  myorder = "I have a {carname}, it is a {model}."
  print(myorder.format(carname = "Ford", model = "Mustang"))
 
  # комбинация позиционных и именованных
  >>> print('The story of {0}, {1}, and {other}.'.format('Bill', 
                                'Manfred', other='Georg'))
  # The story of Bill, Manfred, and Georg.
 
  # подстановка переменных
  # перед строкой буква f чтобы фигурные скобки трактовались как плейcхолдеры
  >>> animals = 'cats'
  >>> print(f'My hovercraft is full of {animals}.')
  # My hovercraft is full of cats.
 
  # Выравнивание строк и чисел, вывод полей:
  >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
  >>> for name, phone in table.items():
  ...     print(f'{name:10} ==> {phone:10d}')
 
  Sjoerd     ==>       4127
  Jack       ==>       4098
  Dcab       ==>       7678
 
  # Кубы и квадраты чисел:
  >>> for x in range(1, 11):
  ...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
 
   1   1    1
   2   4    8
   3   9   27
   4  16   64
   5  25  125
   6  36  216
   7  49  343
   8  64  512
   9  81  729
  10 100 1000
# дополнение нулями
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

if test1:
  statement1
elif test2:
  statement2
else:
  statement3

Части elif и else можно опустить. Отступы обязательны.

x = int(input("Введите ваш вес: "))
if x > 100:
  print("Вам пора заняться спортом")
elif x < 50:
  print("Вам надо больше кушать")
else:
  print("У вас нормальный вес")

Если после двоеточия один оператор, то можно писать в одну строку:

if x == y: print(x)
if x != y: print(x)

expression_if_true if condition else expression_if_false

это эквивалентно

if <condition>: <expression_if_true> else: <expression_if_false>

Как запомнить:

a if condition else b

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

     condition
  if           else
a                   b 

a = 17
b = True if a > 10 else False
print(b) // true
 
is_nice = True
state = "nice" if is_nice else "not nice"
 
# вложенный тернарный:
a = 1
b = 2
 
1 if a > b else -1 if a < b else 0
# Output is -1

Если быть точным, это не оператор, а условное выражение

Также можно реализовать через список (плохая практика, можно ошибиться в последовательности):

[<выражение 1>, <выражение 2>][<условие>]

— будет возвращён результат выражения 1, если условие ложно; и выражения 2, если условие истинно.

Если условие будет не булевым выражением, возможен выход за границы списка с исключением.

использование кортежей:

(if_test_is_false, if_test_is_true)[test]

nice = True
personality = ("вредная", "добрая")[nice]
print("Кошка ", personality)
# Вывод: Кошка добрая  

Это работает поскольку в Python True == 1 и False == 0.

Еще одной причиной не пользоваться тернарным оператором на кортежах является обработка всего кортежа при исполнении, когда как для if-else оператора такого не происходит.

Пример:

condition = True
print(2 if condition else 1/0)
# Вывод: 2
 
print((1/0, 2)[condition])
# Было вызвано исключение ZeroDivisionError

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

явно сконструированный словарь:

result = {True: x, False: y}[a > b]

Если вы работаете со словарями, вместо использования тернарного выражения вы можете воспользоваться get(key, default), например:

shell = os.environ.get('SHELL', "/bin/sh")

также существует более краткий вариант тернарного оператора.

Пример:

True or "Some"
# Вывод: True
 
False or "Some"
# Вывод: 'Some'

Это удобно, когда нужно быстро проверить вернувшееся из функции значение и показать сообщение, если значения не было (вернулся None или 0 или False или пустая строка или пустой список):

func_output = None
msg = func_output or "Не было возвращено данных"
print(msg)
# Вывод: Не было возвращено данных

Все остальные (не пустые) значения расцениваются как истина, поэтому второй операнд OR не вычисляется, а результатом выражения считается первый операнд.

Пример:

print(number%2 and "odd" or "even")
# или более многословно
print(number%2==1 and "odd" or "even")

Это выведет «odd», если число нечетное, или «even», если число четное. Ненадежно, так как если вместо константы «odd» стоит переменная, она может быть пустой и схема не сработает. Можно скорректировать, но это уже нагромождение операторов, и нужно указать какое-то дефолтное значение типа 1:

[condition] and ([expression_1] or 1) or [expression_2] 

1 or 2 — условие считается как true or true = true, однако результатом выражения будет первый операнд, а именно 1

0 or ‘2’ — логический результат true, результат выражения ‘2’

0 or ‘0’ — логический результат false, результат выражения 0

x изменяется в цикле от 0 до 9:

for x in range(0, 10):
  print('Привет, %s!' % x)

Функция range() порождает список целых чисел из полуоткрытого интервала [0, 10).

Цикл по символам строки:

for i in 'hello world':
  print(i * 2, end='') # hheelllloo  wwoorrlldd

Блок else выполняется, когда цикл завершается в нормальном режиме, то есть не был вызван break.

Типичный пример — поиск элемента в коллекции при помощи цикла for. Если элемент найден — мы останавливаем цикл при помощи break. Существует два сценария, при которых может завершиться исполнение цикла. Первый — элемент найден и вызван break. Второй — элемент так и не был найден и цикл завершился. Мы хотим узнать, какой из этих двух вариантов вызвал остановку цикла. Типичным решением будет создание переменной-флага и её проверка после завершения цикла. Другой способ — использование блока else.

for item in container:
    if search_something(item):
        # Нашли!
        process(item)
        break
else:
    # Ничего не найдено...
    not_found_in_container()

Код ниже находит целочисленные делители для n. Мы можем использовать блок else чтобы отслеживать простые числа и выводить их на экран:

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print( n, 'equals', x, '*', n/x)
            break
    else:
        # Цикл не нашел целочисленного делителя для n
        print(n, 'is a prime number')

step = 0
while step < 10000:
  print(step)
  if tired == True:
    break
  elif badweather == True:
    break
  else:
    step = step + 1

В языке Python тело цикла выделяется отступом.

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

Слово else, примененное в цикле for или while, проверяет, был ли произведен выход из
цикла инструкцией break, или же “естественным” образом.

for i in 'hello world':
  if i == 'a':
  break
else:
  print('Буквы a в строке нет')
 
#Буквы a в строке нет

Если же отступ увеличить у двух последних строк, то 11 раз выведет ‘hello world’ — else будет относиться к if