Что означает значок в программировании

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

Программы должны быть написаны для того. Чтобы люди их читали, и только случайно для того. Чтобы машины их выполняли.

Гарольд Абельсон

Одна из определяющих черт языка программирования Python заключается в том. Что он

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

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

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

Чтобы сделать эту задачу немного проще. Я попытаюсь в этом посте и последующих пролить свет на значение – и немного этимологической истории – фундаментальных единиц Python fluency.

В этой первой части мы начнем с самого основного из этих блоков, 35 зарезервированных ключевых слов Python.

Это верно; основной словарь Python, который вам действительно нужно знать. Чтобы начать делать значимую работу. — это всего 35 ключевых слов. Это не самый маленький язык, но он далеко не самый большой, и просто сравните его с примерно 10 000 слов. Необходимых для достижения базовой родной беглости на языке. Не являющемся языком программирования.

Во-первых, Некоторые Условности

Python-это то. Что известно как язык, ориентированный на операторы; но что

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

Но что это за строительные блоки? Что ж, давайте определим их быстро и очень грубо. Поскольку более подробно мы поговорим о них в следующих постах. Я буду использовать заглавные буквы. Чтобы легче было визуально отличить эти абстрактные формы от конкретных примеров. О которых мы поговорим позже.

КЛЮЧЕВОЕ СЛОВО
Зарезервированное слово, значение которого не может быть изменено пользователем.

Мы рассмотрим все 35 из них в следующем разделе этой статьи.

ОПЕРАТОР
Зарезервированный символ, указывающий на действие, которое должно быть выполнено. Например, =это ОПЕРАТОР присваивания и оператор +сложения. Есть еще немало других, но мы прибережем их для следующего поста. Небольшое число ключевых слов ведут себя как операторы, и я укажу на них ниже.

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

что угодно.

ОБЪЕКТ
Индивидуальная вещь, с которой вы можете взаимодействовать. В отличие от ключевых слов и операторов, вы можете непосредственно манипулировать ими, хотя степень. В которой вы можете манипулировать ими. Зависит от типа ОБЪЕКТА. Вы также можете использовать ключевые слова для определения совершенно новых типов, что делает их очень выразительным способом создания собственных новых вещей. Настолько выразительно, что практически все, с чем вы взаимодействуете в Python, будет ОБЪЕКТОМ.

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

А пока просто знайте, что объекты, как правило, делятся на три основные категории.

ЦЕННОСТЬ
ОБЪЕКТ, который представляет собой одну конкретную вещь; для целей этого обсуждения то, что эта вещь на самом деле является несущественным, но в качестве примера, 4является ЗНАЧЕНИЕМ типа int (short for integer) и helloявляется ЗНАЧЕНИЕМ типа str (short for string). Это оба примера примитивных типов, которые имеют одно значимое значение. Но есть также составные типы для описания вещей. Значение которых определяется более чем одним атрибутом Реальным примером может служить прямоугольник. Который не может быть определен без высоты и ширины .

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

КОЛЛЕКЦИЯ
ОБЪЕКТ, который группируется вместе или содержит другие объекты; в Python есть много различных типов коллекций. Но на данный момент все. Что нас волнует, — это то. Что КОЛЛЕКЦИЯ содержит ноль или больше объектов. Например, оператор [2, 3, 4]создает КОЛЛЕКЦИЮ типа list, которая содержит в себе три значения. КОЛЛЕКЦИЯ может содержать любой ОБЪЕКТ, поэтому вы можете вложить КОЛЛЕКЦИЮ в другую КОЛЛЕКЦИЮ.

ПОДЛЕЖАЩИЙ ВЫКУПУ
ОБЪЕКТ, представляющий некоторое действие для выполнения: он выполняет это действие. Когда вы вызываете его с некоторым количеством аргументов, а затем возвращает (или возвращает) ОБЪЕКТ. Например, sum является ВЫЗЫВАЕМЫМ, и когда мы вызываем его с помощьюsum([2, 3, 4]), он возвращает нам ЗНАЧЕНИЕ 9. Есть несколько различных видов вызываемых. И мы коснемся их более подробно ниже.

Однако было бы не очень эффективно вводить один и тот же ОБЪЕКТ каждый раз. Когда вам нужно было бы обратиться к нему. Часто очень полезно иметь возможность ссылаться на вещи косвенно.

ИМЯ
Любое слово. Которое не является КЛЮЧЕВЫМ словом и используется как

псевдоним для обозначения какого-либо конкретного ОБЪЕКТА. В отличие от КЛЮЧЕВОГО СЛОВА, значение ИМЕНИ может меняться в процессе работы программы. Поэтому его часто – хотя и несколько неправильно – воспринимают как переменные. Существует несколько способов создания новых имен (и один-их уничтожения), как мы увидим ниже. Но в качестве простого примера number = 2ОПЕРАТОР присваивания = создает номер ИМЕНИ и присваивает ему ссылку на ЗНАЧЕНИЕ 2. Когда позже это последуетnumber += 2, однако, дополненный ОПЕРАТОР присваивания += будет повторно присваивать номер для ссылки на 4.

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

ВЫРАЖЕНИЕ
Любая составная форма одного или нескольких из вышеперечисленных, которая может быть оценена в ОБЪЕКТ. Например, 4, 2 + 2, 1 * 3 + 1и sum([1, 1, 1, 1])все выражения. Которые вычисляются 4. ВЫРАЖЕНИЕ представляет собой наименьшую дискретную единицу работы в Python.
ЗАЯВЛЕНИЕ
Любая отдельная строка кода, состоящая хотя бы из одного из вышеперечисленных. Они могут быть довольно сложными, но чтобы что-то сделать. Они обычно должны включать ключевые слова и/или операторы плюс выражения.

Вы уже встречались с полезным УТВЕРЖДЕНИЕМ number = 2В. Если вы читаете каждое УТВЕРЖДЕНИЕ в программе по очереди, вы можете проследить. Как программа выполняет свою работу.

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

БЛОК
По крайней мере. Два оператора связаны друг с другом; первый ОПЕРАТОР будет заканчиваться символом : и указывает на начало БЛОКА. Второй и все последующие операторы внутри этого БЛОКА будут иметь отступ правее, чем исходный ОПЕРАТОР. Чтобы указать. Что они принадлежат одному и тому же БЛОКУ. Последний такой ОПЕРАТОР с отступом представляет собой конец БЛОКА.
МОДУЛЬ
Один файл Python .py; он состоит из некоторого количества ОПЕРАТОРОВ. Все программы Python состоят, по крайней мере. Из одного МОДУЛЯ. Как вы увидите ниже, мы пишем всю нашу функциональность внутри модулей, и мы используем ключевые слова и имена. Чтобы импортировать функциональность из других модулей.

Есть много других понятий, с которыми вам нужно будет ознакомиться. Но с этими строительными блоками мы можем исследовать все 35 слов в относительно небольшом словаре Python и. Таким образом. Понять скелет любой программы Python.

Далее к ключевым словам

Тот, Кто Ничего Не Делает

пропуск документов
Заполнитель , технически известный как нулевая операция Python, passвообще ничего не делает; он существует исключительно для того. Чтобы позволить вам написать синтаксически корректный БЛОК.

Общее значение здесь происходит от среднеанглийского глагола. Заимствованного через старофранцузский из латинского passus, что означает “двигаться мимо [места. Не останавливаясь]”. Более конкретно, значение языка Python заимствовано из его использования в последовательных карточных играх. Таких как Бридж, где. Если вы не хотите ничего делать в свой ход, вы передаете управление игрой следующему игроку. Ничего не делая.

Необходимость в этом проста: как только вы начинаете БЛОК в Python, он должен содержать по крайней мере один ОПЕРАТОР с отступом. Чтобы считаться допустимым синтаксисом. Этот passоператор существует для того. Чтобы вы могли написать допустимую БЛОЧНУЮ структуру до того. Как будете готовы начать писать осмысленные операторы.

STATEMENT: pass

Потому что он в основном используется на ранних стадиях при построении грубой структуры программы. Которую вы редко. Если вообще когда-либо увидитеpass в рабочем коде. Но приятно знать. Что он существует.

Три Это Объекты

Следующие три ключевых слова являются специализированными. Поскольку каждое из них ведет себя как примитивное ЗНАЧЕНИЕ. Это означает. Что они могут быть назначены ИМЕНИ. Хранятся в КОЛЛЕКЦИИ и могут быть результатом оценки ВЫРАЖЕНИЯ. Они также являются единственными ключевыми словами. Которые начинаются с заглавной буквы. Что делает их легко различимыми.

Логические значения

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

True docs
Индикатор логической истинности и противоположности False; ведет себя как целое 1число , за исключением того. Что оно всегда будет отображаться как True.

От древнеанглийского прилагательного triewe, которое имеет немецкие корни; общее значение-быть “достойным доверия” и “соответствовать фактам”. В логике, однако, конкретное значение на самом деле просто “то, что не ложно”. А в компьютерном программировании это обычно прокси для двоичной цифры 1.

Фальшивые документы
Индикатор логической неправды и противоположности True; ведет себя как целое 0число , за исключением того. Что он всегда будет отображаться как False.

Из позднего древнеанглийского языка. Заимствованного через старофранцузский faus от латинского falsus; общее значение — “фальшивый. Неправильный. Ошибочный или обманчивый”. В логике это значение не столь зловеще, оно просто означает “то, что не является истинным”. А в компьютерном программировании оно обычно является прокси для двоичной цифры 0.

В некоторых языках более низкого уровня вы, вероятно, просто использовали 1бы и 0для них. Но в Python им были даны специальные ключевые слова. Чтобы сделать очевидным. Что вы работаете с логическим значением, а не с числовым.

Важно понимать, что в Python каждый ОБЪЕКТ (следовательно, каждое ЗНАЧЕНИЕ и КОЛЛЕКЦИЯ, а следовательно, каждое ВЫРАЖЕНИЕ) имеет логическое значение, поскольку считается, что оно логически эквивалентно либо Истине, либо Ложи. Проверка состояния этого логического значения называется тестированием истинностных значений, и, как вы увидите ниже . Ключевые andслова типаor, и ifвсе они полагаются на тестирование истинностных значений для своей работы.

Я более подробно расскажу о специфике тестирования истинностных значений в последующих статьях. Но пока вам просто нужно знать. Что большинство вещей рассматриваются Trueпо умолчанию. За исключением значений “no value”. Таких как0,None, и Falseсамо по себе. А также коллекций “no content”. Таких как [].

Значение null

Это чаще всего используется для представления отсутствия какого-либо другого ЗНАЧЕНИЯ.

Нет документов
Специальное имя для ничего вообще; технически нулевой объект Python; он считается эквивалентным Falseдля тестирования истинностного значения. Но по существу не представляет никакого значения вообще. Очень часто используется в Python и всегда будет отображаться как

None.

Среднеанглийское местоимение от древнеанглийского nan, означающее “не один” или “не любой”. Однако значение в программировании больше относится к нулю, что означает “не [любая] вещь” или просто “ничто”. Python решил использовать none, потому что это более привычное слово. Это также помогает отличить его от использования специального значения NULL в языке программирования C. Которое имеет аналогичное значение. Но ведет себя совсем по-другому.

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

Три для принятия Решений

Быть в состоянии сказать, если что-то считается Trueили Falseне очень полезно. Если у вас нет средств. Чтобы предпринять различные действия. Основанные на этом знании. Для этого большинство языков программирования имеют некоторое представление об условных операциях. В Python есть три ключевых слова, посвященные условным задачам.

если документы
Запускает условный БЛОК, проверяя истинностное значение следующего за ним ВЫРАЖЕНИЯ; ОПЕРАТОР(ы) с отступом под ifним будет выполнен только в том случае. Если это ВЫРАЖЕНИЕ будет рассмотрено

True.

Среднеанглийская конъюнкция от древнеанглийского gif, что означает “в случае” или “ли”, или, как ни странно. Просто “если”. Имеет много скандинавских/германских родственников и, возможно, прибывает через древнескандинавский термин. Означающий “сомнение. Колебание”. Общее употребление состоит в том. Чтобы сделать одно слово или фразу обусловленными тем. Что другое является истинным. Как в “если идет дождь. Откройте свой зонтик”. Смысл в вычислениях более формальный, но по существу тот же: “если [это условие истинно]. То [сделайте какое-нибудь действие].

elif
Необязательно продолжает условное условие, добавляя другой БЛОК; если он присутствует, он должен следовать либо за начальнымif, либо за другим elif. Ведет себя точно так же , как anif, за исключением того. Что его условное ВЫРАЖЕНИЕ будет вычисляться только тогда. Когда ни один предыдущий ifelifОПЕРАТОР / не был вычислен как True.

Не настоящее английское слово, а вместо этого чемодан, который сжимается еще и если в одно искусственное слово, элиф. Вместе это означает “в противном случае. Если” или “в качестве альтернативы, если”. Оба из которых подразумевают. Что действие. Контролируемое elif, зависит от результата какого-либо предыдущего теста или тестов. Итак, в вычислениях “иначе [после проверки некоторого предшествующего условия], если [это другое условие истинно]. То [сделайте какое-то другое действие]“.

ещё
Опционально завершает условное условие добавлением последнего БЛОКА; если оно присутствует, то должно следовать за последним if/elif в БЛОКЕ. Если ни один предыдущий ifelifОПЕРАТОР / не был вычисленTrue, то будет запущен приведенный ниже ОПЕРАТОР(ы) с отступомelse.
Может также использоваться для завершения блоков, начатых с других ключевых слов; см. forwhile, и tryниже.

Наречие от древнеанглийского elles, означающее “[делать] вместо [какого-то другого действия]”. Или “как альтернатива”. Или просто “иначе”. В вычислениях это означает “[проверить. Истинно ли какое-либо предшествующее условие] или [выполнить какое-то окончательное действие]“. Он используется для того. Чтобы предпринять какое-то действие по умолчанию или запасное действие. Когда не следует предпринимать никаких лучших. Более конкретных действий.

Условные обозначения являются ключевыми для многих программ на языке Python и необходимы для лучшего объяснения некоторых следующих ключевых слов. Поэтому я приведу несколько примеров их работы.

Иногда вы хотите предпринять какое-либо действие. Только если выполняется какое-то условие; это самая простая форма:

if EXPRESSION: STATEMENT

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

if EXPRESSION: STATEMENT_A else: STATEMENT_B

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

if EXPRESSION_A: STATEMENT_A elif EXPRESSION_B: STATEMENT_B else: STATEMENT_C

Для среднего случая “или/или” есть другая форма, которую вы иногда увидите. Известная как форма тернарного оператора. Это полезно главным образом потому, что, в отличие от стандартного if условного, он ведет себя как ВЫРАЖЕНИЕ. И значение. Которое он оценивает. Может быть непосредственно присвоено ИМЕНИ:

NAME = STATEMENT_A if EXPRESSION else STATEMENT_B

Что является гораздо более коротким способом написания:

if EXPRESSION: NAME = STATEMENT_A else: NAME = STATEMENT_B

Мы найдем это полезным, когда рассмотрим ключевые слова, подобные ОПЕРАТОРАМ, ниже.

Пятеро Это Операторы

Следующие пять ключевых слов ведут себя как ОПЕРАТОР для обозначения действий. Выполняемых над объектами и/или ВЫРАЖЕНИЯМИ.

Булевы логические операторы

Они используются для проведения значимых сравнений между вещами на основе их истинностной ценности.

не документы
Унарный ОПЕРАТОР. Который инвертирует истинностное значение всего, что следует за ним, как в not EXPRESSION.
Может быть использован для инвертирования значения другого КЛЮЧЕВОГО is notСЛОВА; not inсм.

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

Это логический ОПЕРАТОР отрицания Python, используемый всякий раз. Когда вам нужно противоположное истинностному значению вещи. Он унарный, что означает. Что он действует на то. Что находится справа от него.

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

not EXPRESSION

Если EXPRESSIONсчитаетсяTrue , то not EXPRESSIONоценивается в False и в противном случае он оценивает вTrue .

Это может быть проще понять, если вы думаете о notтом, как работает следующий тернер if :

False if EXPRESSION else True
и документы
Двоичный ОПЕРАТОР. Который проверяет истинностное значение двух вещей , оценивая вещь слева. Если она проверенаFalse, или вещь справа.

Древнеанглийская конъюнкция с германскими корнями смутно означает “затем” или “рядом” и используется для объединения двух слов или фраз. Как в “кофе и чай”. Значение в Python, однако, полностью исходит из логического соединенияи подразумевает , что либо обе вещи. Которые он объединяет, истинны. Либо вся комбинация ложна.

Это логический ОПЕРАТОР связи Python; используется всякий раз. Когда вам нужно проверить. Рассматриваются ли обе стороны andTrue. Это операция короткого замыкания; если рассматривается левое ВЫРАЖЕНИЕFalse, рассматривается вся операцияFalse, и правая сторона никогда не будет оценена вообще. И в отличие notот него не обязательно оценивать либо Trueили False, оценивая вместо этого либо левую сторону (если рассматриватьFalse), либо правую сторону.

Таким образом, использование:

EXPRESSION_A and EXPRESSION_B

Можно думать, как работает, как следующий троичный if :

EXPRESSION_B if EXPRESSION_A else EXPRESSION_A

Вот почему вы можете однажды удивиться, обнаружив. Что True and 1оценивает в 1то время 1 and Trueкак оценивает вTrue .

или документы
Двоичный ОПЕРАТОР. Который проверяет истинностное значение двух вещей , оценивая вещь слева. Если она проверенаTrue, в противном случае вещь справа.

Происходит от древнеанглийского конъюнкта oþþe, означающего “либо” и подразумевающего. Что любая из соединенных идей приемлема. Как в “кофе или чае”. В Python значение исходит из логической дизъюнкциии подразумевает , что либо одна из вещей. Которую он объединяет, истинна. Либо вся комбинация ложна.

Это логический ОПЕРАТОР дизъюнкции Python; используется всякий раз. Когда вам нужно проверить. Рассматривается ли какая — либо сторона orTrue. Это операция короткого замыкания; если рассматривать левое ВЫРАЖЕНИЕTrue, то рассматривается вся операцияTrue, а правая часть вообще никогда не будет оценена. Кроме того, в отличие notот него , он не обязательно оценивает либо Trueодно, либо Falseдругое. Оценивая вместо этого либо левую сторону (если она рассматриваетсяTrue), либо правую.

Таким образом, использование:

EXPRESSION_A or EXPRESSION_B

Можно думать, как работает, как следующий троичный if :

EXPRESSION_A if EXPRESSION_A else EXPRESSION_B

Эта тонкость может застать вас врасплох, когда вы обнаружите, что True or 1оцениваете доTrue , но 1 or Trueоцениваете до 1.

Оператор(ы) проверки личности)

это документы
Двоичный ОПЕРАТОР. Который проверяет, имеет ли ОБЪЕКТ слева ту же идентичность, что и ОБЪЕКТ справа. А затем вычисляет либо Trueили False.
Может быть перевернут, notчтобы стать is notоператором.

Древнеанглийский глагол от германского корня *es-; это третье лицо единственного числа . Присутствующее в указательной форме слова be, поэтому оно обычно означает “быть [вещью]В Python его значение специфично для идентичностии подразумевает что-то вроде “быть [какой-то уникальной вещью]“.

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

EXPRESSION_A is EXPRESSION_B

И использование сnot :

EXPRESSION_A is not EXPRESSION_B

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

В большинстве реализаций Python идентичность ОБЪЕКТА можно рассматривать как его уникальный адрес в памяти. И поскольку каждый ОБЪЕКТ. С которым вы работаете. Будет иметь свой собственный уникальный адрес, isобычно полезно только сказать. Относится ли ИМЯ к определенному ОБЪЕКТУ:

NAME is OBJECT NAME is not OBJECT

Или для проверки того, относятся ли два разных имени к одному и тому же ОБЪЕКТУ в памяти.

NAME is OTHER_NAME NAME is not OTHER_NAME

Однако существуют некоторые особые случаи: например, True , False , и None все они являются синглетонами в памяти. Что означаетTrue , что в любой программе Python существует только одна копия. По большей части это просто компактная деталь, о которой вам не нужно беспокоиться, но она объясняет. Почему в Python мы используемVALUE == True, а не VALUE is True при проверке того. Считается ли что-то эквивалентнымTrue Проверка идентичности-это не то же самое. Что проверка ценности.

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

Оператор(ы) тестирования членства)

в документах
Двоичный ОПЕРАТОР. Который проверяет, является ли ОБЪЕКТ слева членом КОЛЛЕКЦИИ справа. А затем вычисляет либо Trueили False. Также известен как оператор включения Python.
Может быть инвертирован, notчтобы стать оператором not in исключения.
Также используется с for, см. ниже.

Среднеанглийское слияние древнеанглийских слов in, означающих “среди”, и inne, означающих “внутри” или “внутри”. Объединенное слово имеет много употреблений и значений, но общий смысл здесь исходит из предложной формы. Которая подразумевает. Что какая-то вещь содержится внутри или внутри какой-то более крупной вещи. Как в “странице в книге” или “книге в библиотеке”. В Python он специально используется для тестирования членства, при проверке. Если элемент содержится в группе элементов.

Обычно используется inдля проверки, является ли ОБЪЕКТ членом определенного КОНТЕЙНЕРА:

OBJECT in CONTAINER

Или проверить, является ли ОБЪЕКТnot элемент КОНТЕЙНЕРА:

OBJECT not in CONTAINER

Может быть заманчиво думать, что вы можете использоватьis с in , но это неверный синтаксис. Это помогает помнить, что посколькуis ,is not ,in , и not in являются всеми двоичными операторами. Они должны иметь либо ОБЪЕКТ. Либо ВЫРАЖЕНИЕ с любой стороны, а не другое КЛЮЧЕВОЕ СЛОВО.

Четыре, используемые для цикла

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

Запуск цикла

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

Зацикливание до тех пор. Пока не будет достигнуто какое-то условие
в то время как документы
Запускает БЛОК цикла, проверяя истинностное значение ВЫРАЖЕНИЯ; будет непрерывно повторяться до тех пор. Пока ВЫРАЖЕНИЕ не примет значение False.

От древнеанглийского слова hwile для “длительности времени”, но здесь мы используем конъюнктивную форму. Которая подразумевает “[в течение] времени [что-то истинно]” или “до тех пор. Пока [что-то истинно]“. В языках программирования ключевое слово всегда связано с чем-то , что нужно проверить и что-то сделать, поэтому значение становится “пока [тест верен]. [сделать что-то]“.

Форма whileБЛОКА цикла всегда одна и та же:

while EXPRESSION: STATEMENT

Если ВЫРАЖЕНИЕ вычисляется какTrue , то ОПЕРАТОР будет достигнут и выполнен. Когда достигается конец БЛОКА с отступом, элемент управления немедленно возвращается наверх. Затем ВЫРАЖЕНИЕ снова тестируется и так далее. До тех пор. Пока ВЫРАЖЕНИЕ вычисляется как True весь БЛОК с отступом, он будет запускаться снова и снова.

whileЦикл также может быть дополнительно прерван elseБЛОКОМ:

while EXPRESSION: [...] else: STATEMENT

В этом случае УТВЕРЖДЕНИЕ внутриelse блок будет выполнен. Еслиwhile цикл выполняется полностью до завершения (его тест оценивается какFalse ) не сталкиваясьbreak . Это может быть полезно, когда есть некоторое действие очистки, которое должно произойти. Когдаwhile петля вышла естественным образом.

whileЭто самая простая форма петли, но она немного опасна, если не использовать ее с осторожностью. Это происходит потому. Что любое ВЫРАЖЕНИЕ, которое всегда вычисляется какTrue, будет работать вечно. По этой причине, как правило, важно спроектировать ВЫРАЖЕНИЕ так. Чтобы оно в конечном итоге оценивалось False.

Циклический просмотр членов КОЛЛЕКЦИИ
для документов
Запускает БЛОК цикла, который будет повторяться один раз над КОЛЛЕКЦИЕЙ, посещая каждый элемент в ней.
Также можно пометить async, чтобы начать async forцикл, см. ниже.

Древнеанглийское слово через немецкое für с большим количеством значений; общее значение взято из предложного значения “[выполнение действия] от имени [какой-то вещи]“. В вычислительной технике, хотя. По смыслу фактически берется из сокращения слова Для с каждым (что означает “каждый [элемент] в составе группы”) или друг (в значении “все [группы]“). Чтобы сформировать для каждого и для каждого, оба из которых означают “[выполнить действие для каждого элемента [в группе]“. В языках программирования, которые происходят от ALGOL for, традиционно было наиболее распространенным названием для такого цикла, с do используется в меньшем числе языков. Python берет это название из традиционного использования в ALGOL через C. Однако более точно описать версию Python как цикл foreach. Потому что нет явного счетчика, и вещь. Которая зацикливается. Должна быть итерабельной.

Использование forпоследовательно включает в себя присвоение назначенного пользователем ИМЕНИ каждому ОБЪЕКТУ inКОЛЛЕКЦИИ.

for NAME in COLLECTION: STATEMENT

Таким образомfor каждый элемент в КОЛЛЕКЦИИ NAME будет ссылаться на этот элемент внутри области действия БЛОКА; это позволяет ОПЕРАТОРУ использовать NAME для воздействия на эту вещь.

Это может быть немного легче понять, если вы думаете о forспециализированной форме whileцикла:

while [items remain in COLLECTION to visit]: NAME = [increment to the next item] STATEMENT

Но очевидно, чтоfor с циклом гораздо проще работать. Так как вам не нужно беспокоиться о внедрении оборудования. Необходимого для отслеживания условий запуска и остановки цикла. Вы обнаружите, что можете и обычно должны использоватьfor цикл всякий раз. Когда вы посещаете отдельное содержимое КОЛЛЕКЦИИ. А не рискуете сбежать while из цикла.

forЦикл также может быть дополнительно прерван elseБЛОКОМ:

for NAME in COLLECTION: [...] else: STATEMENT

В этом случае УТВЕРЖДЕНИЕ внутриelse блок будет выполнен. Еслиfor цикл работает до завершения без встречbreak . Это может быть полезно, когда есть некоторое действие очистки, которое должно произойти. Когда forцикл вышел естественным образом.

Управление петлей

Вы не всегда хотите просто запустить цикл до завершения; может быть хорошая причина. Чтобы выйти рано или пропустить цикл.

разбить документы
Используется для немедленного прерывания итерации текущего цикла, завершая БЛОК, в котором он находится. По этой причине должен использоваться только внутри БЛОКА цикла.

От древнеанглийского слова брекан, которое имеет несколько форм и значений. Форма существительного обычно означает “повредить, уничтожить или сделать непригодным”, как в “сломать ногу”. Здесь, однако, мы используем альтернативное значение “прерывать [непрерывную последовательность]“. Как в “разорвать электрическую цепь”. В программировании это конкретно означает прерывание цикла изнутри этого цикла.

breakОператор всегда образует свою собственную строку и должен использоваться либо в цикле afor, либо whileв цикле b. Наиболее распространенное использование состоит в том чтобы немедленно остановить цикл если достигнуто какое то конкретное условие:

while True: if EXPRESSION: break STATEMENT
for NAME in COLLECTION: if EXPRESSION: break STATEMENT

Это особенно полезно. Если есть какая-то ситуация, которая требует остановки цикла до того. Как он обычно будет завершен.

продолжайте документы
Сразу же пропускается остальная часть текущего блока цикла, позволяя циклу перейти к следующей итерации. По этой причине он должен использоваться только внутри БЛОКА цикла.

Среднеанглийский глагол, заимствованный через старофранцузского продолжателя из латинского continuare. Общий смысл, используемый здесь, состоит в том. Чтобы “идти вперед или вперед”. “продолжать” или “продолжатьВ программировании это означает. Что цикл начинает выполнять следующую итерацию. Пропуская любые инструкции. Которые следуют за ним.

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

while True: if EXPRESSION: continue STATEMENT
for NAME in COLLECTION: if EXPRESSION: continue STATEMENT

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

Три для Импорта Других Вещей

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

импорт документов
Используется для того. Чтобы привнести функциональность внешнего МОДУЛЯ в ваш собственный код.

Глагол от среднеанглийского importen, через старофранцузский от латинского importare. Общий смысл заключается в том. Чтобы “привезти/перевезти [товары в эту страну] из-за границы”. В вычислительной технике это означает привнести или импортировать некоторую функциональность, экспортированную другой программой. Написанной на том же языке. В текущую программу.

Наиболее распространенное использование очень простое, за ключевым словом следует МОДУЛЬ. К которому вы хотите получить доступ:

import MODULE

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

import MODULE_A, MODULE_B

И в организационных целях вы также можете заключить их в круглые скобки:

import (MODULE_A, MODULE_B)

Любое ИМЯ внутри импортированного МОДУЛЯ(ов) затем может быть доступно в вашей собственной программе с помощью шаблона точечного доступа в форме MODULE.NAME… Так, например. Если вы хотите получить окружность круга:

import math radius = 3 circumference = math.tau * radius

Обычно вы найдете все import варианты использования в верхней части МОДУЛЯ. Что позволяет довольно легко определить. Откуда берется такая функциональность.

От
Модифицируетсяimport, чтобы позволить вам импортировать определенные имена из внешнего МОДУЛЯ.
Также можно использовать с raiseи yield, см. ниже.

Среднеанглийское слово из древнеанглийского fram, здесь мы используем форму предлога. С общим смыслом “отхода или движения прочь [от чего-либо]“; в вычислении мы используем более конкретное значение “взято из источника”.

Он используется для измененияimport, чтобы импортировать определенное ИМЯ из МОДУЛЯ, а не весь МОДУЛЬ:

from MODULE import NAME

Если вы хотите импортировать более одного ИМЕНИ, они могут быть разделены запятыми:

from MODULE import NAME_A, NAME_B

И для организационных целей вы также можете поставить круглые скобки вокруг них:

from MODULE import (NAME_A, NAME_B)

Во всех случаях вы можете использовать импортированное ИМЯ напрямую, например. Если вам нужна область круга:

from math import tau radius = 3 area = tau * radius ** 2 / 2

Основная причина from заключается в том. Чтобы удалить необходимость иметь много ссылок на МОДУЛЬ. Разбросанных по всему коду. Но это лучше зарезервировать для того. Когда МОДУЛЬ имеет много имен. Которые он экспортирует. И вы хотите просто использовать один или два.

как
Изменяетimport, чтобы создать альтернативное ИМЯ (или псевдоним) для импортированного ИМЕНИ.
Также можно использовать с exceptи with, см. ниже.

От древнеанглийского eallswā означает “просто так” или просто “все так”. Что делает его уменьшенной формой также. Употребление здесь происходит от формы наречия. Означающей “[действовать] способом или ролью [какой-либо другой вещи]“. В Python это очень конкретно означает “[с этого момента обращайтесь к этой вещи] как [это вместо этого]“.

Потому fromчто существует две формы использования:

import MODULE as MODULE_ALIAS from MODULE import NAME as NAME_ALIAS

Смысл в том as чтобы позволить вам это сделатьimport какой-то МОДУЛЬ или ИМЯ. Но ссылайтесь на него под каким-то другим именем. Это полезно. Если исходное имя особенно длинное, конфликтует с тем, которое уже используется в вашем коде. Или может просто использовать некоторую дополнительную информацию в контексте.

from math import pi as half_as_good_as_tau

Пять для Исключительных Ситуаций

Теперь, когда у вас есть основы, вы вступаете на более сложную территорию. Что произойдет, если вы обнаружите, что достигли точки в коде, где вы находитесь в очевидном состоянии ошибки. И вы не хотите продолжать? Именно здесь вступает в игру понятие обработки исключений. Мы более подробно рассмотрим стандартные исключения в последующих статьях. Но пока давайте просто скажем. Что ИСКЛЮЧЕНИЕ-это особый тип ЗНАЧЕНИЯ. Обозначающий конкретную проблему. Возникшую в вашей программе. Эта проблема может быть ошибкой в этом случае вы можете захотеть выйти из программы . Или это может быть сигнал о том. Что произошло что-то необычное, но ожидаемое. В любом случае вы должны уметь излучать эти сигналы из собственного кода. А также улавливать и реагировать на такие сигналы. Испускаемые другим кодом.

Сигнализировать, что есть проблема

поднимите документы
Используется для вызова указанного ИСКЛЮЧЕНИЯ. Которое заставит программу немедленно остановиться и выйти. Если exceptБЛОК не обработан.
Если он используется без аргумента внутри exceptfinallyБЛОКА or, то повторно вызывает ИСКЛЮЧЕНИЕ. Обрабатываемое БЛОКОМ.

Среднеанглийское слово со многими значениями, но в данном случае оно происходит от глагольной формы. Означающей “поднимать вертикально. Строить или строить” или “делать выше”. Значение в вычислительной технике более конкретно вытекает из более нового смысла “упомянуть [вопрос. Проблему или аргумент] для обсуждения”. Например “привлечь внимание [к проблеме]“. В некоторых других языках программирования throw используется с аналогичным значением.

Использование, как правило, будет:

raise EXCEPTION

Довольно редко вы можете увидеть прикованную форму:

raise EXCEPTION from OTHER_EXCEPTION

Который используется для указания на то. Что вызываемое ИСКЛЮЧЕНИЕ было вызвано (или произошло) каким-либо другим ИСКЛЮЧЕНИЕМ. Это не часто используется, но иногда полезно, когда вы пытаетесь обработать исключение, вызванное другим кодом. Но почему-то не можете сделать это.

Наконец, внутри exceptБЛОКА вы можете просто:

Который будет повторно вызывать любое ИСКЛЮЧЕНИЕ, которое в настоящее время обрабатывается внутри этого БЛОКА.

Сигнализировать, что определенное условие не выполнено

assert docs
Используется для проверки того. Считается ли какое-то ВЫРАЖЕНИЕ Истинным, а если нет. То вызывает AssertionError.

От латинского assertus, с общим значением “объявленный, защищенный или заявленный”. В программировании это конкретно означает указать. Что условие должно быть выполнено в определенной точке кода. И ошибиться. Если это не так.

Использование assertобычно происходит в форме:

assert EXPRESSION

Который будет простоraise AssertionError если ВЫРАЖЕНИЕ не вычисляется какTrue .

Альтернативная форма позволяет указать сообщение:

assert EXPRESSION, "something is wrong!"

И это сообщение будет включено в AssertionError.

Это assertутверждение существует для того. Чтобы вы проверяли то, что необходимо Trueдля того. Чтобы ваша программа продолжала работать (мы называем это вашими инвариантами). Это может быть очень полезно при разработке и отладке, но на это вообще не следует полагаться впроизводственном коде. Поскольку человек . Выполняющий вашу программу. Может отключить все assertоператоры. Передав параметр -Oкомандной строки Python. В основном вы можете себе представить. Что assertработает как:

if [the -O command line flag was not passed]: if not EXPRESSION: raise AssertionError

… за исключением того. Что если -Oбы флаг был передан, тоassert утверждение будет просто заменено, passи ничего вообще не произойдет.

Ловить сигнал и реагировать на него

Имея и raiseто, и другое, и assertв своем инструментарии вы знаете, как сигнализировать об ИСКЛЮЧЕНИИ. Но как вы ловите его и реагируете на него (или игнорируете)? Именно здесь вступает в игру механизм обработки исключений Python.

попробуйте docs
Запускает БЛОК обработчика исключений; за ним должен следовать либо exceptБЛОК, либо elseблок, либо finallyБЛОК. Чтобы быть допустимым синтаксисом.

Глагол, заимствованный из старого французского слова trier, означающего Значение в Python, по сути. Одно и то же: “[начать] тест [чего-то. Что может привести к ошибке]“.

кроме
Необязательно продолжает БЛОК обработчика исключений. Перехватывая исключения; может (и должен) ограничиваться определенными типами ИСКЛЮЧЕНИЙ. Более одного из них может следовать за atry, и каждый из них будет проверяться по очереди до тех пор. Пока либо ИСКЛЮЧЕНИЕ не будет обработано. Либо больше exceptне останется операторов.

Глагол, заимствованный из средне-французского excepter и латинского exceptus; первоначальное значение — “получать”. Но более общее использует его для “исключения [чего-либо]” или “возражения против [чего-либо]“. Как в “каждом фрукте. Кроме яблок”. Это значение в Python немного расплывчато, но его можно рассматривать как “поймать. Захватить или поймать [исключение]“. На самом деле во многих других языках catch используется для той же цели; исключение из этого правила составляет исключение Python except.

наконец
Опционально очищает БЛОК обработчика исключений. Чтобы обеспечить возможность всегда выполнять какое-либо действие независимо от того. Было ли обработано ИСКЛЮЧЕНИЕ или нет. Должен следовать за любыми exceptБЛОКАМИ, которые присутствуют, а также за необязательным elseБЛОКОМ. Если он также присутствует. Если exceptБЛОК отсутствует, то finally необходимо завершить работу обработчика исключений.

От среднеанглийского fynaly означает “в конце или заключении” или просто “наконец”. Оно подразумевает самую последнюю вещь. Которую нужно сделать в последовательности, что и здесь имеет значение.

Обработка исключений-это первое обстоятельство, с которым вы столкнулись. Когда за одним БЛОКОМ должен следовать другой. И правила несколько сложнее, чем все. Что вы когда-либо видели. Например существуют две различные минимальные синтаксически допустимые формы обработчика исключений:

try: BLOCK finally: STATEMENT

Эта форма фактически не обрабатывает никаких ИСКЛЮЧЕНИЙ, возникающих внутри БЛОКА, она просто гарантирует. Что ОПЕРАТОР выполняется при любых обстоятельствах. Любое не обработанное ИСКЛЮЧЕНИЕ будет продолжать “подниматься” до тех пор. Пока оно либо не будет обработано. Либо не приведет к сбою вашей программы. Это полезно в ситуациях, когда требуется выполнить одно и то же действие (например. Закрыть файл или соединение с базой данных) независимо от того. Произошла ошибка или нет.

Вторая форма действительно обрабатывает ИСКЛЮЧЕНИЕ:

try: BLOCK except: STATEMENT

Примечание: поскольку эта форма будет перехватывать любое ИСКЛЮЧЕНИЕ, включая несколько. Которые используются Python для выполнения критических операций. Вытически говоря, никогда не должны использовать приведенную выше форму. Вместо этого используйте минимальную безопасную форму:

try: BLOCK except EXCEPTION: STATEMENT

Это гарантирует. Что обработчик исключений обрабатывает только указанный тип исключения. Иерархия встроенных исключений в Python сложна и затрагивает концепции. Которые мы не можем охватить в этой статье. Но пока просто знаем. Что except Exceptionэто наименее конкретноexcept оператор. Который вы всегда должны использовать в производственном коде.

Эта минимальная безопасная форма, однако, не особенно полезна, потому что ОПЕРАТОР не может на самом деле знать. Какое ИСКЛЮЧЕНИЕ он обрабатывает. Большую часть времени вы будете видеть что-то вроде этого:

except EXCEPTION as NAME: STATEMENT

Который используется as для предоставления псевдонима. Который может быть использован для проверки фактического ИСКЛЮЧЕНИЯ. Которое было вызвано. Это может быть очень полезно для того. Чтобы точно увидеть, что пошло не так, что поможет вам решить. Можете ли вы игнорировать проблему или должны каким-то образом реагировать.

Вы также можете указать несколько различных типов ИСКЛЮЧЕНИЙ для перехвата, что может быть полезно. Если вы хотите реагировать на любую из этих форм одинаково:

except (EXCEPTION_A, EXCEPTION_B, EXCEPTION_C) as NAME: STATEMENT

И если вы хотите ответить на них каждый по своему вы можете просто сложить их вместеexcept БЛОКИ:

except EXCEPTION_A as NAME: STATEMENT_A except EXCEPTION_B as NAME: STATEMENT_B

Вы также можете опционально использоватьelse с обработчиком исключений. Если хотя бы один из нихexcept оператор используется. И до тех пор. Пока else он позиционируется перед любымfinally :

try: BLOCK_A except EXCEPTION as NAME: BLOCK_B else: STATEMENT

Однако это происходит относительно редко. Потому что ЗАЯВЛЕНИЕ с отступом подelse будет выполняться только в том случае. Если внутри системы не было вызвано ИСКЛЮЧЕНИЕ.try БЛОК и нет break , continue , илиreturn в нем встречались высказывания.

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

try: [connect to database] [query the database] except ConnectionError as error: [log the error] else: [log success] finally: [close the connection]

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

Четыре для записи функций

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

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

Анонимные (безымянные) функции

Многие люди, обучающие (и изучающие) Python. Склонны пропускать анонимные функции или относиться к ним как к расширенной функции. Но на самом деле это происходит только потому. Что они плохо названы. “Анонимная” часть просто означает. Что функция не получает определенного имени во время создания. Это может показаться не самой простой вещью для повторного использования-и вы правы, – но полезно понять их. Прежде чем перейти к именованным функциям. Потому что они фундаментально проще и более ограничены.

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

лямбда -документы
Используется для определения вызываемой анонимной функции и ее сигнатуры.

11-я буква классического греческого алфавита, λ; она не имеет общего значения в английском языке. В Python он используется потому . Что анонимные функции являются фундаментальной единицей лямбда-исчисления Алонсо Черча, которая обеспечивает большую часть математических основ современных вычислений. В качестве чести это приятно; на самом деле лямбда использовалась бы чаще. Если бы у нее было более забавное название.

Несмотря на название, a lambdaна самом деле является концептуально самой простой формой функции в Python. Потому что вы можете думать о ней как о простом способе создания ВЫРАЖЕНИЯ отложенной оценки. Которое задается в определенной форме:

lambda : EXPRESSION

Который вычисляется в ВЫЗЫВАЕМЫЙ объект, который будет вычислять ВЫРАЖЕНИЕ, которое приходит после двоеточия. Только когда ВЫЗЫВАЕМЫЙ объект сам вызывается. Чтобы вызвать его, вы используете синтаксис вызова, который является общим для всех вызываемых объектов Python, однако. Поскольку lambda сам объект является ВЫРАЖЕНИЕМ. Для этого его нужно окружить круглыми скобками.

(lambda : EXPRESSION)()

И вуаля, все. Что вы только что написали, будет мгновенно заменено тем. Что оценит внутреннее ВЫРАЖЕНИЕ.

Таким образом, все три из них полностью идентичны:

x = (lambda : 2 + 2)() x = 2 + 2 x = 4

Но просто откладывать ВЫРАЖЕНИЕ-не самый полезный инструмент. Таким lambda образом, вводится идея сигнатуры функции: вы можете добавить ИМЯ в левую часть двоеточия, и то. На что ссылается это ИМЯ. Будет использоваться внутри внутреннего ВЫРАЖЕНИЯ при его вычислении. Это имя известно как параметр функции.

Вот a lambdaс одним параметром:

lambda NAME: EXPRESSION

И вот один с двумя параметрами:

lambda NAME_A, NAME_B: EXPRESSION

И когда мы захотим использоватьlambda мы просто вызываем его. Передавая конкретное ЗНАЧЕНИЕ для каждого параметра в сигнатуре:

(lambda NAME_A, NAME_B: EXPRESSION)(VALUE_A, VALUE_B)

Который как вы можете себе представить может быть полезен если мы хотим вычислить площадь прямоугольника:

lambda width, height: width * height

Но, опять же, мы закончим тем. Что напишем это много раз, если не присвоим ему ИМЯ:

area = lambda width, height: width * height square = area(2, 2) rectangle = area(3, 5)

Отлично! То squareесть сейчас 4и rectangleесть 15; у нас есть основа повторного использования кода!

Но lambdaбудет довольно неприятно, когда ВЫРАЖЕНИЕ начнет становиться длинным. И помимо этого есть некоторые довольно значительные ограничения. Так как мы на самом деле не можем выполнять много видов операторов внутри lambda, а тем более произвольного БЛОКА. У них есть свое место, но, может быть, есть лучший и более гибкий путь?

Поскольку мы только что присвоили ИМЕНИ то, что считается анонимной функцией (что означает “не имеет имени”). Давайте посмотрим. Как мы обычно пишем функции в Python.

Именованные функции

Именованная функция строится на идеях lambdaпроекта, но переносит их в гораздо более гибкое место. Позволяя довольно легко повторно использовать большие куски кода. Их тоже немного сложнее освоить, потому что они оцениваются не совсем так, как ВЫРАЖЕНИЕ. На самом деле по умолчанию они всегда будут оценивать значение toNone, если только вы явно не скажете им сделать иначе.

def docs
Используемый для определения именованной функции и ее сигнатуры, выделенный БЛОК, который следует. Может затем быть повторно использован. Вызвав это ИМЯ с помощью function()синтаксиса.
Если используется внутри aclass, вместо этого определяется именованный метод, который вызывается с помощью class.method()синтаксиса.
Также можно отметить async, чтобы начать async def, см. Ниже.

Сокращение слова define, которое происходит через среднеанглийское deffinen от старофранцузских и латинских корней. Это глагол, который означает “уточнять или фиксировать [значение слова или фразы]“. В Python он используется специально для создания именованной подпрограммы. В других языках вместо них часто используются define , fn, fun, func, functionи let.

Поскольку defего можно использовать для создания произвольно сложных вызываемых объектов. Это потребует некоторого объяснения. По сути, он используется для создания нового ИМЕНИ, которое ссылается на ВЫЗЫВАЕМЫЙ ОБЪЕКТ. На самом деле, с этого момента давайте просто использовать ФУНКЦИЮ, чтобы иметь в виду именно это:

def FUNCTION(): STATEMENT

Это определяет ФУНКЦИЮ , которую можно вызвать с помощью usingFUNCTION(), которая затем будет выполнять каждый ОПЕРАТОР внутри БЛОКА с отступом. Как видите, это концептуально эквивалентно слову “именованный”.lambda форма, которую вы видели раньше. Сравните эти две формы:

def FUNCTION(NAME_A, NAME_B): STATEMENT FUNCTION = lambda NAME_A, NAME_B : STATEMENT

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

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

def FUNCTION(NAME): STATEMENT

И точно так же, как сlambda у нас может быть несколько параметров:

def FUNCTION(NAME_A, NAME_B): STATEMENT

Что позволяет нам построить areaфункцию, которую мы сделали раньше с помощьюlambda :

def area(width, height): width * height square = area(2, 2) rectangle = area(3, 5)

Только, погоди-ка … разве я не сказал чуть вышеdef функции оцениваются следующим образомNone когда звонили? Да, прямо сейчас оба squareи rectangleназначены наNone Мы вычислили две области, но затем отбрасываем их снова. Как только локальная область действия areaзакрывается. А теперь, как, черт возьми , нам выбраться отсюдаarea?

Остановите функцию и верните значение
возврат документов
Используется для немедленного отказа от контроля и завершения выполнения функции в точке. В которой она встречается. Если за ним следует ВЫРАЖЕНИЕ, то оно вычисляется первым. А результирующий ОБЪЕКТ возвращается вызывающему объекту функции. Если никакого ВЫРАЖЕНИЯ нетNone, то оно возвращается вместо него. Не имеет никакого значения вне функции, поэтому, если она вообще присутствует. Она должна быть внутри БЛОКА. Следующего за a def.

Среднеанглийский глагол от старофранцузского retourner, означающий “повернуть назад” или “вернуться [в прежнее положение]“. В вычислительной технике оно имеет два значения:

  1. Непереходное значение — “вернуть (или отказаться) управление [вызывающей процедуре]“. Как в “когда функция выходит. Она возвращает управление”.
  2. Транзитивный смысл — “передать [некоторые данные] обратно вызывающей процедуре”. Как в “эта функция вернет текущее время”.

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

Самое простое использование returnнемедленно завершает функцию и возвращается Noneвызывающему объекту:

Эта форма используется относительно редко; как уже упоминалось ранее. Функция всегда вычисляется None по умолчанию; таким образом. Вы можете себе представить. Что return это неявная последняя строка каждой функции.

Из-за этого его гораздо чаще можно увидеть:

return EXPRESSION

Который немедленно вычисляет ВЫРАЖЕНИЕ и возвращает результирующий ОБЪЕКТ обратно вызывающему.

Вы также можете использовать returnдля передачи обратно более одного ОБЪЕКТА:

return EXPRESSION_A, EXPRESSION_B

Это вычисляет каждое ВЫРАЖЕНИЕ по очереди. Завершает функцию и возвращает кортеж (тип КОЛЛЕКЦИИ фиксированной длины). Содержащий один ОБЪЕКТ для каждого ВЫРАЖЕНИЯ.

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

Вы заметите, что return функция завершается в момент ее вычисления. Все, что находится ниже этой точки в функции. По существу не существует (за одним исключением-finallyблок внутри обработчика исключений). Итак, как бы вы справились с ситуациями, в которых вам нужно было вернуть данные. Но после этого продолжать работать?

Приостановите функцию и верните значение
документы по доходности
Используется. Чтобы немедленно приостановить выполнение и временно отказаться от контроля в точке. В которой он встречается. Если за ним следует ВЫРАЖЕНИЕ, то оно вычисляется первым. И результирующий ОБЪЕКТ возвращается вызывающему объекту функции; если же никакого ВЫРАЖЕНИЯ нетNone, то он возвращается вместо него. Не имеет никакого значения вне функции, поэтому, если она вообще присутствует. Она должна использоваться внутри БЛОКА. Следующего за a def.
Может быть изменен с помощью fromформы yield from, см. ниже.

Этимологически самое странное слово в этом списке происходит от среднеанглийского yielden и древнеанглийского gieldan, оба из которых означают “платить”. И имеют общий корень с древнескандинавским gjald и немецким geld, оба из которых означают “деньги”. Сегодня гелд означает древнюю форму принудительного налога или выкупа, но также означает “кастрировать”. Исторически Дангельд был налогом, взимаемым с англичан их королем. Этот налог был поднят, чтобы заплатить волнам датских викингов, чтобы, по-видимому. Не кастрировать англичан (или. По крайней мере. Их короля). Ничто из этого не имеет здесь прямого значения, но может объяснить. Почему смысл в вычислениях происходит как от “уступить и отказаться от контроля”. Как в “отдаче встречного трафика”. Так и “вернуть [результат или возврат инвестиций]”. Как в “фонд имеет доходность 5% в год”. В обоих случаях подразумевается, что ситуация еще не окончательна и , скорее всего, повторяется: вы уступаете, затем ждете. Затем снова уступаете.

В Python это помогает вспомнить аллегорию: returnесть Смерть, и приходит ровно один раз. В то время yieldкак есть Налоги. И может закончиться только тогда. Когда придет Смерть.

Использование yieldаналогичноreturn :

yield EXPRESSION
yield EXPRESSION_A, EXPRESSION_B

Однако любая функция, которая использует yield его, на самом деле возвращает особый вид КОЛЛЕКЦИИ. Известный как ГЕНЕРАТОР при вызове. В отличие от обычной КОЛЛЕКЦИИ ГЕНЕРАТОР не хранит все свои элементы в памяти одновременно. А вместо этого “генерирует” каждый элемент по мере необходимости. Проходя через функцию до yield тех пор. Пока не встретится и не выдаст элемент. ГЕНЕРАТОР приостанавливает выполнение в этот момент, позволяя коду, использующему ГЕНЕРАТОР. Работать с этим элементом. При желании он может запросить следующий элемент. После чего ГЕНЕРАТОР продолжает работать до следующего yield и так далее . Пока их больше не останется yield операторы. Оставленные для запуска или return встреченные a.

Это то. Что позволяет следующую форму:

yield from GENERATOR

Который является специализированным случаем использования, который позволяет написать ГЕНЕРАТОР. Который будетyield каждый предмет. В свою очередь, от другого ГЕНЕРАТОРА.

Подробное объяснение генераторов выходит за рамки этой серии статей. Поскольку они являются довольно продвинутой темой. На данный момент достаточно знать. Что если вы столкнетесьyield, вы смотрите на ГЕНЕРАТОР.

Три для манипулирования пространствами имен

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

В самом простом случае пространство имен-это, по сути, просто место, где Python хранит любое созданное вами ИМЯ. Поэтому они используются всякий раз. Когда Python нужно найти ОБЪЕКТ. На который ссылается это ИМЯ. Каждое пространство имен имеет областьдействия . Которая ограничивает продолжительность “жизни” пространства имен и то. Является ли какое-либо ИМЯ в нем читаемым и/или записываемым данным ОПЕРАТОРОМ. Однако пространства имен образуют иерархию, поэтому запомнить правила может быть немного сложно.

В любом заданном пространстве имен ОПЕРАТОР может:

  1. как чтение так и запись любого ИМЕНИ определенного в его собственном пространстве имен
  2. чтение, но не записьлюбого ИМЕНИ , определенного в заключающем родительском пространстве имен
  3. ни чтение, ни запись ИМЕНИ. Определенного в одноуровневом или дочернем пространстве имен

На верхнем уровне находится собственное пространство имен Python, которое содержит все встроенные имена. Которые Python предоставляет для вас. Это пространство имен не может быть записано, и любое ИМЯ в нем, по существу, живет вечно.

Далее идет глобальное пространство имен. Которое является пространством имен МОДУЛЯ. В котором вы работаете; оно становится родительским для всех других пространств имен. Созданных в этом МОДУЛЕ. Любое ИМЯ, определенное здесь, обычно живет в течение всего времени работы программы.

Далее каждый вызываемый создании получает свой уникальный локального пространства имен , когда он вызывается; любое имя создавшего здесь живет лишь постольку. Поскольку вызываемая работает. И когда он закончится. Как объект относится к будут уничтожены. Если либо return или yield используется. Чтобы передать его обратно вызывающему области.

Поскольку вы можете определить ВЫЗЫВАЕМЫЙ объект, вложенный в другой ВЫЗЫВАЕМЫЙ объект. Вы можете построить иерархию пространств имен произвольной глубины. Так что любое заданное ИМЯ может существовать в любом количестве пространств имен. Все дальше и дальше удаляясь от того места. Где вы на самом деле пытаетесь использовать это ИМЯ. Однако это может стать громоздким, чтобы думать об этом довольно быстро. Поэтому мы стараемся ограничить количество вложений. Которые мы делаем в практическом коде.

Назначение нового ИМЕНИ довольно просто: если оно не изменено одним из ключевых слов ниже. ИМЯ всегда назначается в области. В которой происходит ОПЕРАТОР присваивания.

Но использование ИМЕНИ немного менее очевидно: при использовании в ОПЕРАТОРЕ Python сначала ищет ИМЯ в непосредственной локальной области. Если он не может найти ИМЯ, то он ищет непосредственную родительскую область (известную как нелокальная), а затем продолжает искать каждую последующую родительскую область до тех пор. Пока либо не найдет ИМЯ. Либо не сможет разрешить его и ошибки.

Все это, как правило, несколько невидимый механизм существует, чтобы позволить вам писать код, используя имена. Которые являются подходящими и понятными для области. В которой вы работаете. Пока это не ключевое слово и вам не нужно использовать ИМЯ из области действия предка. Вы можете использовать любое ИМЯ локально и не беспокоиться о том. Что оно перезапишет что-либо за пределами своей собственной области действия.

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

Пишите наверх из любого места

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

глобальные документы
Используется для объявления ИМЕНИ как части глобального пространства имен; это ИМЯ не могло ранее использоваться в том же пространстве имен. По сути, это позволяет локальному ОПЕРАТОРУ как создавать, так и присваивать глобальное ИМЯ. Которое в противном случае он мог бы только читать. Может использоваться в глобальном пространстве имен, но не имеет никакого эффекта.

Прилагательное, заимствованное из французского языка, с общим значением “всемирный” и “универсальный”. В вычислениях смысл-это конкретно “[ИМЯ, которое] доступно всем частям программы”. В Python это и самое верхнее пространствоимен , которое читается из всех функций и методов. Но также является ключевым словом. Которое связывает локальное имя в глобальное пространство имен. Позволяя ему быть доступным для записи из этого локального пространства имен.

Использование довольно простое; основное ограничение заключается в том. Что он не может появиться после использования ИМЕНИ:

global NAME NAME = EXPRESSION

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

Напишите родителю от ребенка

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

нелокальные документы
Используется исключительно внутри вложенных функций / методов (также известных как замыкания) для привязки уже существующего ИМЕНИ в родительском пространстве имен. Это позволяет ОПЕРАТОРУ в дочернем элементе иметь доступ на запись к ИМЕНИ. Определенному в его родительском элементе. Должно появиться перед любой ссылкой на это ИМЯ в локальной области видимости.

Прилагательное. Образованное путем сочетания префикса non- (“не”) и local (“относящийся к определенному месту”). Это прежде всего научно-технический неологизм (буквально “новое слово”). Который не имеет истинного общего значения. А имеет только конкретные значения в конкретных областях. В программировании это означает нелокальную переменную, то есть “[ИМЯ, которое] доступно ни в локальном, ни в глобальном пространстве именВ Python он очень конкретно относится к пространству имен заключающей функции с точки зрения вложенной функции. А также является ключевым словом. Связывающим локальную функцию. ИМЯ внутри этой вложенной функции в нелокальное пространство имен. Позволяющее ей быть доступной для записи из вложенной функции.

Поскольку он используется только внутри вложенной функции. Использование всегда будет включать некоторую заключающую структуру:

def OUTER_FUNCTION(): NAME = VALUE def INNER_FUNCTION(): nonlocal NAME NAME = EXPRESSION INNER_FUNCTION()

Главное, что нужно понять, — это то, чтоnonlocal используется аналогично global , но с более ограниченной целью сделать переменную в родительской вложенной функции доступной для записи. Он также имеет аналогичные предостережения, хотя тот факт, что его воздействие не ощущается всей программой. Делает его по своей сути менее опасным. Тем не менее, его использование очень узко и относительно мало, поэтому постарайтесь не злоупотреблять им. Когда будет достаточно передачи аргументов.

Убейте его огнем

До сих пор вы видели, как добавить ИМЯ в пространство имен, но как удалить ИМЯ из пространства имен?

del docs
Используется для удаления ИМЕНИ (или имен) из пространства имен; если других ссылок на ОБЪЕКТ. На который ссылается это ИМЯ. Не существует. Базовый ОБЪЕКТ также удаляется.
Может также использоваться для удаления атрибута ОБЪЕКТА или члена (или членов) КОЛЛЕКЦИИ, если конкретный тип разрешил эту операцию.

Сокращение delete, которое, в свою очередь, является глаголом, производным от латинского deletus. Его общий смысл заключается в том. Чтобы “уничтожить или искоренить”. “стереть или стереть” и “полностью удалить”. И хотя конкретный смысл в вычислениях немного менее силен. Он имеет аналогичный эффект. В Python значение немного косвенное: del используется для удаления ссылки, которую пользователь непосредственно контролирует. Что может косвенно вызвать удаление вещи. На которую ссылается. Из памяти процесса. Которой управляет интерпретатор.

Наиболее распространенным использованием является предоставление одного ИМЕНИ:

Однако также допустимо указывать несколько имен, разделенных запятыми:

del NAME_A, NAME_B, NAME_C

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

Поскольку эффект ограничен ближайшим пространством имен. Вы должны использовать globalили nonlocalудалить ИМЯ за пределами локального пространства имен:

global NAME del NAME

Вы также можете использовать del для удаления атрибутов объектов и членов коллекций, однако то. Что происходит на самом деле. Зависит от типа ОБЪЕКТА / КОЛЛЕКЦИИ. КОЛЛЕКЦИЯ list, например, позволяет использовать del для удаления как отдельных индексов, так и фрагментов ее содержимого:

test = [1, 2, 3] del test[0] # deletes the first item del test[:] # deletes all items

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

Один для определения новых типов объектов

До этого момента я довольно смутно представлял себе, что такое ОБЪЕКТ на самом деле. В парадигме объектно-ориентированного программирования, также известной как ООП, объект-это, в основном, вещь, которая имеет как состояние (в форме именованных атрибутов), так и поведение (в форме вызываемых методов). Две отдельные вещи одного и того же типа могут иметь различные конкретные значения для этих атрибутов – мы называем их различными экземплярами одного и того же типа – но они имеют общий общий интерфейс. Однако есть немного больше, чем это; программист должен быть в состоянии определить частичные интерфейсы. Которые мы будем называть чертами, что типы со сходными потребностями могут реализовываться по-разному. Так что все они имеют некоторые общие атрибуты и поведение (свойство. Известное как полиморфизм). Кроме того, эти черты должны быть способны передаваться от более общих типов к более конкретным типам через механизм наследования. Подобно тому. Как родитель передает черты своим детям.

Вы можете взять пример с природы; утка-это тип птицы, и она наследует определенные черты. Которые она разделяет со всеми птицами. Все птицы являются типом животного, и таким образом наследуют определенные черты, общие всем животным. Животное-это тип жизни, и так далее. Таким образом, Говард, специфическая утка, имеет все атрибуты и поведение жизни, животных, птиц и уток. Все красиво свернутое в одном экземпляре типа утки.

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

документы класса
Используется для определения шаблона для нового типа ОБЪЕКТА.

Существительное заимствовано через французский классе от латинского классис, что означает “разделение. Армия, флот”. “народ Рима под ружьем”. Ини странно, конкретно. “ни одна из шести заказы в Сервия Туллия. Который разделил римский народ для целей налогообложения”. Который прошел долгий путь, объясняя. Почему английский язык такой сложный язык для освоения. Общее значение. Которое мы используем здесь, хотя и слабо заимствовано из эволюционной таксономии. Подразумевая “группу. Которая разделяет определенные наследуемые черты”. Специфическое значение в Python происходит от Объектно-ориентированного программирования и подразумевает “шаблон для создания объектов. Которые имеют общее наследуемое состояние (атрибуты) и поведение (методы)”.

В Python вы определяете новый тип, создавая новое ИМЯ. Которое также является ВЫЗЫВАЕМЫМ; отныне мы будем называть его КЛАССОМ. classКлючевое слово используется для запуска нового БЛОКА. Который определяет реализацию этого КЛАССА:

class CLASS: pass

Теперь КЛАСС можно вызвать для создания нового экземпляра своего типа:

NAME = CLASS()

Теперь, исходя из вышесказанного, вы можете ожидать. Что этот экземпляр не будет иметь никаких атрибутов или поведения. Но на самом деле он имеет минимальный интерфейс. Общий для всех объектов (например. Его можно распечатать и использовать в сравнениях. Хотя и не очень полезно). Он получает это потому , что все новые class определения неявно наследуются от object, который является базовым типом Python.

Вы также можете указать более общий КЛАСС (также известный как суперкласс) для наследования:

class CLASS(SUPERCLASS): pass

На самом деле вы часто захотите наследовать более чем от одного суперкласса, чтобы смешать их различные черты. Это делается путем разделения суперклассов запятыми:

class CLASS(SUPERCLASS_A, SUPERCLASS_B): pass

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

Просто определение КЛАССА и его суперклассов без предоставления ему каких-либо собственных атрибутов и методов является необычным. Поэтому обычно вы видите как минимум пользовательский метод инициализатора. Который по соглашению делается путем определения специального двойного подчеркивания (или “dunder”) метода экземпляра __init__:

class CLASS: def __init__(self, NAME): self.NAME = NAME

Как вы можете видеть, метод экземпляра-это просто другой вид определения функции. Выполненный с использованиемdef . На самом деле МЕТОД-это просто ФУНКЦИЯ, которая была добавлена в пространство имен КЛАССА. Вот именно, тот самыйclass ключевое слово также создает новый вид локального пространства имен. Которое остается прикрепленным к КЛАССУ и позволяет искать имена либо в экземпляре, либо в самом классе с помощью шаблонов точечного доступа INSTANCE.NAME и CLASS.NAME… Обратите внимание на имя параметра self в приведенном выше определении метода? Так условно называется первый параметр любого метода экземпляра, и это то, как вы получаете доступ к атрибутам. Установленным на самом экземпляре.

Все это звучит немного абстрактно, поэтому давайте продемонстрируем это. Построив КЛАСС для размышления о кругах.

from math import tau class Circle: def __init__(self, radius): self.radius = radius def diameter(self): return self.radius * 2 def circumference(self): return self.radius * tau def area(self): return tau * self.radius ** 2 / 2

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

unit = Circle(1)

Мы можем получить доступ и распечатать атрибут self.radius:

print(unit.radius)

И мы также можем вызвать любой из его методов, но обратите внимание. Что нам никогда не нужно передавать радиус окружности в качестве аргумента. Поскольку все методы могут получить доступ к нему через self:

print(unit.diameter()) print(unit.circumference()) print(unit.area())

Поскольку они являются фундаментальным строительным блоком всего в модели данных Python, есть много , что можно сказать о классах в Python, и есть много тонкостей. Которые могут пойти в их правильное использование (и неправильное злоупотребление). Поэтому мы будем часто возвращаться к ним в последующих статьях этой серии. А пока главное — начать осознавать, как class используется для их создания. И как используются экземпляры при доступе к их атрибутам и методам. Также полезно знать. Что существует довольно много методов “dunder”. И что они используются для реализации многих общих функций “под капотом”. Которые поддерживают все встроенные функции, с которыми мы начнем встречаться в последующих статьях.

Один для работы в контексте

Иногда есть действия, которые вы всегда хотите выполнить в определенном контексте, например. Совершить транзакцию базы данных или закрыть сетевое соединение. Такие вещи обычно включают в себя некоторую форму обработки исключений или другой шаблон. Специфичный для данной задачи. И это может привести к большому количеству шаблонов. Которые необходимо повторить. Пример является чем-то таким же простым. Как чтение файла: открытие файла обязательно должно означать получение некоторых ресурсов из базовой операционной системы. И вы всегда хотите освободить эти ресурсы. Даже если вы случайно попытались открыть файл. Который не существовал или у вас не было разрешений на чтение. Файл-это тип ОБЪЕКТА. Который всегда будет нести в себе контекстную потребность управлять ресурсом с помощью него. И поэтому вам нужно будет писать то же tryсамое и finallyшаблонно каждый время открытия файла.

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

с документами
Запускает БЛОК context manager, который гарантирует. Что отступы под ним выполняются в контексте управляемого ОБЪЕКТА.
Также можно отметить async, чтобы начать async with, см. Ниже.

Среднеанглийский предлог, который берет свое произношение от одного древнеанглийского термина wið (“против”). Но берет свое современное значение от другого, mid (“в ассоциации с”), который. В свою очередь. Происходит от немецкого mit. Значение в Python происходит изнутри, что означает “внутри области или контекста [какой-то вещи или события]“.

Любое использование withтребует ВЫРАЖЕНИЯ. Которое вычисляется до ОБЪЕКТА. Удовлетворяющего интерфейсу типа context manager, и таким образом реализовало оба метода __enter__ и __exit__” dunderОтныне мы будем называть это ВЫРАЖЕНИЕ CONTEXT_MANAGER. Чтобы сделать примеры более понятными.

В самом простом использовании вы просто начинаете новый БЛОК:

with CONTEXT_MANAGER: STATEMENT

Который войдет в контекст путем вызова CONTEXT_MANAGER.__enter__(), выполнит ИНСТРУКЦИЮ в контексте. А затем выйдет из контекста путем вызова CONTEXT_MANAGER.__exit__().

Но чаще всего вы захотите использовать asдля назначения возвращаемого ОБЪЕКТА CONTEXT_MANAGER.__enter__()псевдоним. Чтобы БЛОК мог работать с ним:

with CONTEXT_MANAGER as NAME: STATEMENT

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

with open(path) as src: contents = src.read()

Это гораздо проще чем то что вам пришлось бы написать в противном случае:

src = open(path) try: contents = src.read() finally: src.close()

Иногда вам захочется работать в нескольких КОНТЕКСТНЫХ МЕНЕДЖЕРАХ:

with CONTEXT_MANAGER_A as NAME_A, CONTEXT_MANAGER_B as NAME_B: STATEMENT

Что работает точно так же как вложенность одного with в другое:

with CONTEXT_MANAGER_A as NAME_A: with CONTEXT_MANAGER_B as NAME_B: STATEMENT

Вы познакомитесь с несколькими контекстными менеджерами, когда будете работать в стандартной библиотеке Python. И теперь вы знаете. Что создание своего собственного-это всего лишь вопрос создания нового class и реализации нескольких методов “dunder”.

И, Наконец,… Два для Асинхронной работы

Любая функция или метод, с помощью которых вы пишетеdef, по определению синхронны, то есть в тот момент . Когда вы вызываете ее. Ваш запущенный код должен остановить все остальное и ждать, сколько бы времени это ни заняло. Чтобы ваша функция либо returnyieldвернулась к нему. Либо управляла им. Прежде чем может быть выполнен остальной код. Для большинства задач, которые происходят на локальной машине, это разумно и прекрасно. Особенно когда вам нужен ответ. Прежде чем вы сможете продолжить.

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

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

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

асинхронные документы
Используется для пометки другого КЛЮЧЕВОГО СЛОВА как работающего асинхронно. Как таковой, async не может появиться сам по себе.
С defпомощью as async defможно определить асинхронную функцию, также известную как СОПРОГРАММА.
С forпомощью as async forзацикливаться на асинхронном итераторе внутри an async def.
withasync withЧтобы использовать асинхронный контекстный менеджер внутри async def, см. Ниже.

Как вы уже догадались, это сокращение современного английского слова асинхронный, которое образовано путем объединения латинских корней а- (“не”) и син- (“вместе”) с Хронусом, древнегреческой олицетворением времени. Это однозначно означает “не происходящее одновременно”. В Python он более конкретно отмечает операцию как “не происходящую в то же время, что и вызывающий”. Что позволяет вызывающему ожидать результата этой операции. Которая произойдет в какой-то момент в будущем.

Поскольку значение asyncпривязано к ключевому слову, которое оно отмечает, его использование всегда одинаково:

async KEYWORD

Однако, в отличие от любого другого ключевого слова, которое мы видели. Использованиеasync всегда будет начинаться с определения нового КОРУТИНА:

async def COROUTINE(): STATEMENT

Обе другие формыasync существует, чтобы позволить вам работать в корутине с другими корутинами. Иим образом. Они могут существовать только внутриasync def .

Например, вы можете использовать async forцикл над асинхронным итератором, таким как ГЕНЕРАТОР КОРУТИН (который просто КОРУТИН. Который использует yieldвместо return).

async def COROUTINE(): async for item in GENERATOR_COROUTINE: STATEMENT

Вы также можете использоватьasync with для выполнения работы в контексте асинхронного контекстного менеджера:

async def COROUTINE(): async with CONTEXT_MANAGER_COROUTINE as NAME: STATEMENT

Практически каждая СОПРОГРАММА должна будет ждать других СОПРОГРАММ, поэтому существует еще одно ключевое слово. Которое может быть использовано только внутри СОПРОГРАММЫ.async def .

ждите документов
Используется для приостановки выполнения СОПРОГРАММЫ, она находится внутри и ждет. Пока СОПРОГРАММА правильно завершится; может использоваться только внутри async defСОПРОГРАММЫ .

От среднеанглийского глагола awaiten (“ждать”) от старофранцузского awaitier/agaitier (“подстерегать. Наблюдать или наблюдать”). Общее чувство более активно и враждебно , чем ожидание, которое является его модификацией. В асинхронном программировании это означает “[приостановить выполнение] и ждать [завершения чего-либо]“.

awaitКлючевое слово всегда будет использоваться для вызова КОРУТИНА внутриasync def :

async def OUTER_COROUTINE(): await COROUTINE()

Который приостановит выполнение внешнего соротина и будет ждать, пока вызванный СОРОТИН, в конечном счете. Не вернет управление. Любое ЗНАЧЕНИЕ , возвращаемое вызываемой КОРУТИНОЙ, передаетсяawait , так что вы можете думать об await COROUTINE()асинхронном ВЫРАЖЕНИИ. Которое в конечном итоге будет вычисляться независимо от того. Что возвращается КОРУТИНОЙ при вызове.

Конечно, теперь, когда у вас есть основы асинхронной работы, как вы на самом деле выполняете такую работу? Ну, а что касается Python 3.7, то для этого все еще требуется использовать функциональность. Предоставляемую модулем asyncio, подробности которого выходят далеко за рамки этих статей. Подробнее см. асинхронный праймер, о котором я упоминал ранее.

Фу…

Вот они, 35 ключевых слов Python: самих по себе недостаточно. Чтобы вы свободно владели Python. Но если вы прочитали это далеко и переварили его. То вы уже на пути к истинному пониманию (а не просто использованию) скелета того. Что происходит в одном из самых быстрорастущих общих языков программирования в мире. В следующем посте этой серии мы сделаем шаг в сторону от слов и вместо этого рассмотрим символы, погрузившись в немного меньший. Но, к счастью, гораздо более простой список операторов Python.