35 слов, которые вам нужен в Python

В начале были ключевые слова Python

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

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

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

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

Правда состоит в том, что вам нужно достаточно овладения «правилами» английской грамматики и WordPlay, чтобы распознать и понять, на первый взгляд, слова написано на английском, что не На самом деле слова вы найдете в английском словаре. Нестандартные термины, такие как деф (A Сжатие ), элиф (A Portmanteau ) и нелокальный (A неологизм ) все изобилует, поэтому даже для тех, кто с довольно продвинутой родной Английское беглость Задача обучения Python очень нравится пытаться выучить иностранный язык, который слегка связанные с их родным языком. Для тех, которые без этого беглости обучения Python похож на изучение иностранного языка внутри иностранный язык, и поэтому Далеко труднее.

Чтобы сделать эту задачу немного легче, я собираюсь попробовать, в этом посте и те, которые следуют, чтобы пролить свет по значению – и Маленький Из этимологической истории позади – фундаментальные единицы беглости Python. В этой первой части мы начнем с самых основных из этих единиц, Python’s 35 Ключевые слова ¹ Отказ

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

Во-первых, некоторые конвенции

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

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

{‘dt’: {‘strong’: ‘КЛЮЧЕВОЕ СЛОВО’}}

{‘dd’: [‘Зарезервировано’, {’em’: ‘слово’}, ‘смысл которого’, {’em’: ‘может нет’}, ‘быть измененным пользователем. Мы посетим все 35 из них в следующем разделе этой статьи.’]}

{‘strong’: ‘Оператор’}

{‘dd’: [‘Зарезервировано’, {’em’: ‘символ’}, ‘это указывает на действие, которое будет выполнено. Например,’, {‘code’: ‘=’}, ‘это’, {’em’: ‘назначение’}, ‘Оператор и’, {‘code’: ‘+’}, ‘это’, {’em’: ‘добавление’}, ‘Оператор. Есть довольно много других, но мы сохраним их для следующего поста. Небольшое количество ключевых слов ведут себя как операторы, и я укажу тем ниже.’]}

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

{‘dt’: {‘strong’: ‘ОБЪЕКТ’}}

{‘dd’: [‘Индивидуальный’, {’em’: ‘вещь’}, ‘Вы можете взаимодействовать с. В отличие от ключевых слов и операторов, вы можете напрямую манипулировать этим, хотя степень, в которой вы можете манипулировать их, зависит от Какие’, {’em’: ‘тип’}, ‘объекта они есть. Вы также можете использовать ключевые слова, чтобы определить совершенно новые’, {’em’: ‘типы’}, ‘, что делает их очень выразительным способом строительства нового’, {’em’: ‘вещи’}, ‘из ваших собственных. Так выразительно, на самом деле, что практически говорить’, {’em’: ‘все’}, ‘Вы взаимодействуете с в Python, будет объектом.’]}

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

{‘dt’: {‘strong’: ‘ЦЕННОСТЬ’}}

{‘dd’: [‘Объект, который представляет собой один, бетон’, {’em’: ‘вещь’}, ‘; для целей этой дискуссии, что это на самом деле’, {’em’: ‘является’}, ‘не имеет значения, но в качестве примера,’, {‘code’: ‘4’}, ‘это ценность’, {‘a’: [{‘strong’: ‘int.’}, {‘href’: ‘https://docs.python.org/3/library/functions.html#int’}]}, ‘(Короче для’, {’em’: ‘целое число’}, ‘) Тип и’, {‘code’: ‘Привет’}, ‘это ценность’, {‘a’: [{‘strong’: ‘ул’}, {‘href’: ‘https://docs.python.org/3/library/functions.html#func-str’}]}, ‘(Короче для’, {’em’: ‘нить’}, ‘) тип. Это оба примера’, {’em’: ‘примитивный’}, ‘типы, которые имеют одно значимое значение, но есть также’, {’em’: ‘составной’}, ‘типы для описания вещей, смысл которого определяется более чем одним’, {’em’: ‘атрибут’}, ‘. Реальный пример будет прямоугольником, который не может быть определен без высоты, так и ширины. Как вы увидите ниже трех специальных ключевых слов, все ведут себя как ценности, хотя, как и прежде, не сможете изменить их значение.’]}

{‘strong’: ‘КОЛЛЕКЦИЯ’}

{‘dd’: [‘Объект, который объединяет или содержит другие объекты; Есть’, {’em’: ‘многие’}, ‘разные виды коллекций в Python, но на данный момент все, что мы заботимся о том, это то, что коллекция’, {’em’: ‘содержит’}, ‘ноль или более объектов. Например заявление’, {‘code’: ‘[2, 3, 4]’}, ‘Создает коллекцию типа’, {‘a’: [{‘strong’: ‘список’}, {‘href’: ‘https://docs.python.org/3/library/stdtypes.html#list’}]}, ‘который содержит три значения внутри этого. Коллекция может содержать’, {’em’: ‘любой’}, ‘Объект, так вы может’, {’em’: ‘гнездо’}, ‘Коллекция внутри другой коллекции.’]}

{‘strong’: ‘Callable.’}

{‘dd’: [‘Объект, представляющий некоторые действия для выполнения: он выполняет это действие, когда вы называете его несколькими’, {’em’: ‘аргументы’}, ‘тогда Это’, {’em’: ‘возвращается’}, ‘(или возвращает) объект. Например’, {‘a’: [{‘strong’: ‘сумма’}, {‘href’: ‘https://docs.python.org/3/library/functions.html#sum’}]}, ‘вызывается, и когда мы это называем с использованием’, {‘code’: ‘сумма ([2, 3, 4])’}, ‘Это дает нам значение’, {‘code’: ‘9’}, ‘. Существует несколько различных видов Callable, и мы настроим на них более подробно ниже.’]}

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

{‘dt’: {‘strong’: ‘НАЗВАНИЕ’}}

{‘dd’: [‘Любое слово тот’, {’em’: ‘не является’}, ‘ключевое слово, и это используется как’, {’em’: ‘псевдоним’}, ‘к’, {’em’: ‘Ссылаться на’}, ‘какой-то конкретный объект. В отличие от ключевого слова значения имени’, {’em’: ‘мая’}, ‘Изменение в течение программы, поэтому это часто – если немного неправильно – мысль как’, {’em’: ‘переменные’}, ‘. Есть несколько способов создавать новые имена (и их уничтожить их), как мы увидим ниже, но как простой пример в’, {‘code’: ‘номер’}, ‘то’, {’em’: ‘назначение’}, ‘Оператор’, {‘code’: ‘=’}, ‘создает имя’, {‘strong’: ‘номер’}, ‘и назначает его ссылаться на стоимость’, {‘strong’: ‘2’}, ‘. Когда позже следует’, {‘code’: ‘номер’}, ‘, тем не мение, то’, {’em’: ‘Расширенное задание’}, ‘Оператор’, {‘code’: ‘+=’}, ‘будет повторно назначать’, {‘strong’: ‘номер’}, ‘ссылаясь на’, {‘strong’: ‘4’}, ‘.’]}

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

{‘dt’: {‘strong’: ‘ВЫРАЖЕНИЕ’}}

{‘dd’: [‘Любая композитная форма одного или нескольких из вышеперечисленного, которая может быть’, {’em’: ‘оцениваться’}, ‘к объекту. Например,’, {‘code’: ‘4’}, ‘,’, {‘code’: ‘2 + 2’}, ‘,’, {‘code’: ‘1 * 3 + 1’}, ‘и’, {‘code’: ‘сумма ([1, 1, 1, 1])’}, ‘все выражения, которые оценивают в’, {‘code’: ‘4’}, ‘. Выражение представляет собой наименьшую дискретный единицу работы в Python.’]}

{‘strong’: ‘УТВЕРЖДЕНИЕ’}

{‘dd’: [‘Любая одна строка кода, которая состоит по крайней мере из одного из вышеперечисленных. Они могут стать довольно сложными, но чтобы’, {’em’: ‘делать’}, ‘Все, что они обычно должны включать ключевые слова и/или операторы плюс выражения. Вы уже встречались’, {’em’: ‘полезный’}, ‘Выписка’, {‘code’: ‘номер’}, ‘. Если вы прочитаете каждое утверждение в программе, в свою очередь, вы можете отслеживать программу, поскольку она выполняет свою работу.’]}

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

{‘dt’: {‘strong’: ‘БЛОКИРОВАТЬ’}}

{‘dd’: [‘По крайней мере, два утверждения, которые связаны вместе; Первое утверждение закончится в’, {‘strong’: ‘:’}, ‘символ и указывает на начало блока. Второе и все дополнительные заявления внутри этого блока будут отступать далее, чем первоначальное утверждение, чтобы указать, что Oни’, {’em’: ‘принадлежать’}, ‘к тому же блоку. Последнее такое утверждение отступа представляет собой конец блока.’]}

{‘strong’: ‘Модуль’}

{‘dd’: [‘Один файл Python .py; Он состоит из некоторого количества заявлений. Все программы Python состоят из хотя бы одного модуля. Как вы увидите ниже, мы пишем все наши функциональные возможности внутри модулей, и мы используем ключевые слова и имена к’, {’em’: ‘Импортировать’}, ‘Функциональные возможности из других модулей.’]}

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

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

Тот, который делает Ничего такого

{‘dt’: [‘проходят’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/tutorial/controlflow.html?highlight=pass#pass-statements’}]}]}

{‘dd’: [“Заполнитель; технически известный как Python’s”, {’em’: ‘нулевая операция’}, ‘,’, ‘проходят’, ‘ничего не делает ничего; Это существует исключительно, чтобы позволить вам написать синтаксически действительный блок.’]}

Общее значение здесь происходит от среднего английского глагола, заимствованного через старый французский от латыни пасс что подразумевает «Переместить [место, не останавливая]» Отказ Более конкретно смысл в Python заимствован из его использования в последовательных играх-картах, таких как мост, где, если вы не хотите ничего делать на вашем повороте, вы пройти Контроль игры на следующий игрок, ничего не делая.

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

STATEMENT:
    pass

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

Три, которые являются объектами

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

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

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

{‘dt’: [‘Истинный’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3.7/library/stdtypes.html#boolean-values’}]}]}

{‘dd’: [‘Индикатор логика’, {’em’: ‘правда’}, ‘и противоположность’, ‘Ложь’, ‘; ведет себя как то’, {’em’: ‘целое число’}, ”, {‘code’: ‘1’}, ‘за исключением того, что он всегда будет отображаться как’, ‘Истинный’, ‘.’]}

От старого английского прилагательного Truve у которого есть немецкие корни; Общее значение является «достойным доверием» и «согласуется с фактом». Однако в логике конкретное значение – это действительно просто «то, что не является ложным», а в компьютерном программировании обычно является прокси для двоичной цифры 1.

{‘dt’: [‘Ложь’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3.7/library/stdtypes.html#boolean-values’}]}]}

{‘dd’: [‘Индикатор логика’, {’em’: ‘неправда’}, ‘и противоположность’, ‘Истинный’, ‘; ведет себя как то’, {’em’: ‘целое число’}, ”, {‘code’: ‘0’}, ‘за исключением того, что он всегда будет отображаться как’, ‘Ложь’, ‘.’]}

С позднего старого английского, заимствованного через старый французский Faus от латыни falsus ; Общее значение имеет «поддельные, неправильные, ошибающиеся или лживые». В логике смысл не так зловещий, это просто означает «то, что не правда», а в компьютерном программировании обычно это прокси для двоичной цифры 0.

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

Важно понимать, что в Python каждый Объект (отсюда иначе ценить и коллекция, и, следовательно, каждое выражение), имеет логично Значение, в том, что он считается логически эквивалентным к истинному или ложному. Тестирование состояния этого логического значения известно как Тестирование ценностей правды и как вы увидите ниже ключевых слов, таких как и , или и Если Все полагаются на тестирование ценностей правды для их работы.

Я пойду в более глубокую деталь о специфике тестирования ценности правды в более поздних статьях, но на данный момент вам просто нужно знать, что большинство вещей считаются Истинный По умолчанию, за исключением значений «без значения», таких как 0 , Нет и Ложь Сама, а также «нет контента» коллекций, таких как [] .

Нулевое значение

Это чаще всего используется для представления отсутствия какого-либо другого значения.

{‘dt’: [‘Никто’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/library/stdtypes.html#the-null-object’}]}]}

{‘dd’: [‘Специальное имя ни за что ни за что; Технически Питон’, {’em’: ‘Нулевый объект’}, ‘; Это считается эквивалентным’, ‘Ложь’, ‘Для тестирования ценностей правды, но по существу, представляет никакого значения вообще. Очень часто используется в Python, и всегда появится как’, ‘Никто’, ‘.’]}

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

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

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

Возможность сказать, если что-то считается Истинный или Ложь Не очень полезен, если у вас нет средств, чтобы принять разные действия, основанные на этих знаниях. Для этого Большинство Языки программирования имеют некоторое понятие Условные операции Отказ В Python есть три ключевых слова, посвященные условному заданиям.

{‘dt’: [‘если’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#the-if-statement’}]}]}

{‘dd’: [‘Запускает условный блок, проверив’, {’em’: ‘ценность правды’}, ‘выражения, которое следует за этим; утверждение (ы) с отступом под’, ‘если’, ‘будет выполнен, только если выражение считается’, ‘Истинный’, ‘.’]}

Среднее английское соединение со старого английского Гиф Что означает «в мероприятии» или «будь то» или, странно, просто « если ». Имеет много скандинавских/германских родственников, и, возможно, прибывает через старый Норвейский термин для «сомнения, колебаний». Общее использование состоит в том, чтобы сделать одно слово или фразу условно на другой, как в « » Если Идет дождь, открыть свой зонт ». Смысл в вычислениях более формально, но по существу одинаково; « Если [Это условие верно], то [делать некоторые действия].

{‘dt’: ‘элиф’}

{‘dd’: [‘По выбору’, {’em’: ‘продолжается’}, ‘Условный, добавляя другой блок; Если это предложить’, {’em’: ‘должен’}, ‘Следуйте либо начальному’, ‘если’, ‘или Другая’, ‘элиф’, ‘. Ведет себя точно так же, как’, ‘если’, ‘за исключением того, что его условное выражение будет оценено только когда нет предыдущего’, ‘если’, ‘/’, ‘элиф’, ‘Заявление оценивалось как’, ‘Истинный’, ‘.’]}

Не правильное английское слово, а вместо этого Портманто Это контракты еще и Если в одно искусственное слово, Элиф Отказ Вместе это означает «иначе, если» или «как альтернатива, если», оба из которых подразумевают, что действие, контролируемое Элиф зависит от исхода некоторых предыдущих тестов или испытаний. Итак, в вычислении: « else [После проверки некоторых предыдущих условий] Если [Это другое условие верно], то [делать некоторые другие действия] ».

{‘dt’: ‘еще’}

{‘dd’: [‘По выбору’, {’em’: ‘заканчивается’}, ‘Условный, добавляя конечный блок; Если это предложить’, {’em’: ‘должен’}, ‘Следуйте последним’, ‘если’, ‘/’, ‘элиф’, ‘в блоке. Если нет предыдущего’, ‘если’, ‘/’, ‘элиф’, ‘Утверждение оценивается в’, ‘Истинный’, ‘затем оператор отступов (ы) ниже’, ‘еще’, ‘будет запущен.’]}

Наречие со старого английского Эллс , что означает «[делать] вместо [каких-либо других действий]» или «как альтернатива», или просто «в противном случае». В вычислении это означает «[проверьте, является ли какое-либо предыдущее условие] else [выполнить некоторые окончательные действия] ». Он используется для принятия некоторого значения по умолчанию или затруднен, если не следует предпринять более конкретные действия.

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

Иногда вы хотите только взять любой действие, если некоторое условие выполнено; Это самая простая форма:

if EXPRESSION:
    STATEMENT

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

if EXPRESSION:
    STATEMENT_A
else:
    STATEMENT_B

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

if EXPRESSION_A:
    STATEMENT_A
elif EXPRESSION_B:
    STATEMENT_B
else:
    STATEMENT_C

Для середины, «либо/или« случай »есть другая форма, которую вы иногда видите, известный как Темнарный оператор форма. Это полезно в основном потому, что в отличие от стандарта Если условный, он ведет себя как выражение, а Значение, которое он оценивает, может быть непосредственно назначен на имя:

NAME = STATEMENT_A if EXPRESSION else STATEMENT_B

Который гораздо более короткий способ написания:

if EXPRESSION:
    NAME = STATEMENT_A
else:
    NAME = STATEMENT_B

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

Пять, которые являются операторами

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

Логические логические операторы

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

{‘dt’: [‘нет’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not’}]}]}

{‘dd’: [‘A’, {’em’: ‘одинарный’}, ‘Оператор, который инвертс то’, {’em’: ‘ценность правды’}, ‘Из того, что следует за этим, как в’, {‘code’: ‘не выражение’}, ‘.’]}

Средний английский наречие со старого английского Nawiht , подразумевая «ничего» или «ноль». Общее значение сегодня отрицает (или переворачивает) значение слова или фразы, которая следует за ней. Сравните «У меня есть яблоки», чтобы «Я делаю не У яблок». Однако в программировании конкретное значение происходит от Логическое отрицание и таким образом не Ответятся верно к ложным, и наоборот.

Это Python’s Логическое отрицание Оператор, используется всякий раз, когда вам нужна противоположность ценности правды. Это Унарный , что означает, что он действует на то, что это к его немедленному праву.

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

not EXPRESSION

Если Выражение Считается Истинный тогда Не выражение оценивает Ложь и в противном случае он оценивает Правда Отказ

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

False if EXPRESSION else True

{‘dt’: [‘и’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not’}]}]}

{‘dd’: [‘A’, {’em’: ‘двоичный’}, ‘Оператор, который проверяет’, {’em’: ‘ценность правды’}, ‘из двух вещей, оценивая вещь слева Если это проверено’, ‘Ложь’, ‘иначе до того, что справа.’]}

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

Это Python’s Логическое соединение Оператор; используется всякий раз, когда вам нужно проверить, если оба Стороны и считаются Правда Отказ Это короткое замыкание операция; Если выражение левого руки считается Ложь вся операция считается Ложь И правая сторона никогда не будет оценена вообще. И в отличие от не Это не обязательно оценивает либо Правда или Ложь , оценивая вместо в левую сторону (если рассматривается Ложь ) или правая сторона.

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

EXPRESSION_A and EXPRESSION_B

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

EXPRESSION_B if EXPRESSION_A else EXPRESSION_A

Вот почему вы, возможно, один день найду себя удивленным, обнаружив, что Правда и 1 оценивает 1 в то время как 1 и правда оценивает Правда Отказ

{‘dt’: [‘или’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not’}]}]}

{‘dd’: [‘A’, {’em’: ‘двоичный’}, ‘Оператор, который проверяет’, {’em’: ‘ценность правды’}, ‘из двух вещей, оценивая вещь слева Если это проверено’, ‘Истинный’, ‘иначе до того, что справа.’]}

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

Это Python’s Логическая дизъюнкция Оператор; используется всякий раз, когда вам нужно проверить, если либо сторона или Считается Правда Отказ Это короткое замыкание операция; Если выражение левого руки считается Истинный вся операция считается Правда И правая сторона никогда не будет оценена вообще. Также, в отличие от не Это не обязательно оценивает либо Правда или Ложь , оценивая вместо в левую сторону (если рассматривается Правда ) или правая сторона.

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

EXPRESSION_A or EXPRESSION_B

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

EXPRESSION_A if EXPRESSION_A else EXPRESSION_B

Эта тонкость может вытащить вас, когда вы найдете это Правда или 1 оценивает Истинный Но 1 или правда оценивает 1 Отказ

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

{‘dt’: [‘является’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/expressions.html#is’}]}]}

{‘dd’: [‘A’, {’em’: ‘двоичный’}, ‘Оператор, который тестирует, если объект слева имеет то же’, {‘a’: [‘личность’, {‘href’: ‘https://en.wikipedia.org/wiki/Identity_(object-oriented_programming)’}]}, ‘как объект справа, а затем оценивает либо’, ‘Истинный’, ‘или’, ‘Ложь’, ‘.’]}

Старый английский глагол из германского ствола * ; Это третье лицо единственное присутствующее ориентировочная форма слова быть Так что это вообще означает «быть [вещь]». В Python его значение специфично для Личность и подразумевает что-то большее, как «быть [некоторая уникальная вещь]».

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

EXPRESSION_A is EXPRESSION_B

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

EXPRESSION_A is not EXPRESSION_B

Понятие Личность Это немного абстрактно, но думать об этом, как это: Том и Боб – близнецы, они одинаковые высоты, возраста и вес, и они разделяют один и тот же день рождения, но они Не иметь такую же идентичность. Том Том, и Боб Боб, но Том не Боб.

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

NAME is OBJECT
NAME is not OBJECT

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

NAME is OTHER_NAME
NAME is not OTHER_NAME

Там являются Однако некоторые особые случаи: например, Правда , Ложь , и Нет все Singletons В память, что означает только когда-либо Одна копия Правда в любой Python Program. По большей части это просто детализация космического пространства, о которых вам не нужно беспокоиться, но она объясняет, почему в Python мы используем ЦЕННОСТЬ и не Значение верно При проверке ли что-то считается эквивалентно к Правда Отказ Тестирование Личность это не так же, как тестирование ценность .

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

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

{‘dt’: [‘в’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/expressions.html#membership-test-operations’}]}]}

{‘dd’: [‘A’, {’em’: ‘двоичный’}, ‘Оператор, который тестирует, если объект слева является членом коллекции справа, а затем оценивает либо’, ‘Истинный’, ‘или’, ‘Ложь’, “. Также известен как Python’s”, {’em’: ‘Оператор включения’}, ‘.’]}

{‘dd’: [‘Можно перевернуть’, ‘нет’, ‘стать’, ‘не в’, {’em’: ‘Оператор исключений’}, ‘.’]}

{‘dd’: [‘Также используется с’, ‘за’, ‘, увидеть ниже.’]}

Средний английский слияние старых английских слов в , смысл “среди” и inne , значение «внутри» или «внутри». Объединенное слово имеет много использований и значений, но общий смысл здесь находится из предложной формы, что подразумевает, что некоторые вещи содержатся внутри или внутри некоторой большей вещи, как в «странице в книга« или » Книга в Библиотека “. В Python он специально используется для Тестирование членства При проверке ли элемент содержится в группе элементов.

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

OBJECT in CONTAINER

Или тестировать, если объект имеет не Член контейнера:

OBJECT not in CONTAINER

Может быть заманчиво думать, что вы можете использовать это с в , но это неверный синтаксис. Это помогает помнить, что с это , не , в и не в все бинарные операторы они Должен иметь либо объект, либо выражение по обе стороны, не другое ключевое слово.

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

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

Начало петли

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

Зацикливаться, пока не будет достигнуто некоторое состояние

{‘dt’: [‘пока’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#the-while-statement’}]}]}

{‘dd’: ‘Начинает блок петли путем тестирования ценности правды выражения; непрерывно произойдут, пока выражение не оценивается до false.’}

От старого английского слова HWILE Для «продолжительности времени», но вот мы используем конъюнктивную форму, которая подразумевает «[во время] времени [что что-то верно]» или «до тех пор, пока [что-то верно]». На языках программирования ключевое слово всегда связано с чем-то для Тест и что-то до сделать Так что смысл становится ” в то время как [Тест правда], [сделать что-то] ».

Форма в то время как Лорт-блок всегда одинаковы:

while EXPRESSION:
    STATEMENT

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

в то время как петля также может При желании быть прекращенным еще БЛОКИРОВАТЬ:

while EXPRESSION:
    [...]
else:
    STATEMENT

В этом случае утверждение внутри еще Блок будет выполнен, если в то время как Цикл проходит весь путь к завершению (его тест оценивает False ) без столкнуться с ломать . Это может быть полезно, когда есть некоторое действие очистки, которое должно происходить, когда A в то время как петля вышел естественно.

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

Зацикливаться через членов коллекции

{‘dt’: [‘за’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#the-for-statement’}]}]}

{‘dd’: [‘Запускает блок петли это будет итерации’, {’em’: ‘однажды’}, ‘За коллекцию, посещение каждого элемента в нем.’]}

Старое английское слово через немецкий шерсть с большим многочисленным значениями; Общее значение взято из предлогового смысла «[выполнение действия] от имени [некоторая вещь]». Однако в вычислениях смысл на самом деле воспринимается от сокращения слова для с либо каждый (Значение «каждый [элемент] в группе«) или каждый (означает «все [группы]»), чтобы сформировать Для каждого или для каждого , оба из которых означают «[для выполнения действия] от имени каждого предмета [в группе]». На языках программирования спускается от Algol для Традиционно было наиболее распространенным именем для такого цикла, с сделать используется в меньшем количестве языков. Python принимает имя от традиционного использования в ALGOL через C, однако точнее описать версию Python в качестве Foreach цикл, потому что нет явного счетчика и то, не будучи накинут должны быть итерацию Отказ

Использование для последовательно включает в себя присвоение назначенного пользователем имени каждому объекту в Коллекция.

for NAME in COLLECTION:
    STATEMENT

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

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

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

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

для петля также может При желании быть прекращенным еще БЛОКИРОВАТЬ:

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

В этом случае утверждение внутри еще Блок будет выполнен, если для Цикл запускается до завершения без столкнуться с ломать . Это может быть полезно, когда есть некоторое действие очистки, которое должно происходить, когда A для петля вышел естественно.

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

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

{‘dt’: [‘ломать’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-break-statement’}]}]}

{‘dd’: [‘Используется для немедленного прерывания текущей петли итерации, заканчивая блок, он находится внутри. По этой причине должен’, {’em’: ‘Только’}, ‘использоваться в блоке петли.’]}

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

Перерыв Заявление всегда образует свою собственную линию, и это Должен использоваться в либо для или в то время как петля. Наиболее распространенное использование – это немедленно остановить цикл, если определенное условие достигнуто:

while True:
    if EXPRESSION:
        break
    STATEMENT

for NAME in COLLECTION:
    if EXPRESSION:
        break
    STATEMENT

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

{‘dt’: [‘Продолжать’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-continue-statement’}]}]}

{‘dd’: [‘Сразу пропускает оставшуюся часть текущего блока петли, позволяя петлю продолжаться к следующей итерации. По этой причине должен’, {’em’: ‘Только’}, ‘использоваться в блоке петли.’]}

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

Продолжить Заявление всегда образует свою собственную линию, и она должна использоваться в либо для или в то время как петля. Наиболее распространенное использование – это немедленно пропустить следующую итерацию цикла, когда определенное условие достигнуто:

while True:
    if EXPRESSION:
        continue
    STATEMENT

for NAME in COLLECTION:
    if EXPRESSION:
        continue
    STATEMENT

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

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

Все вышеперечисленное, плюс Встроенный Функции мы поговорим в более поздней статье, достаточно для того, чтобы вы начнете использовать Python в качестве Сценарии Язык, где вы приклеите все, что другие написали с вашим собственным кодом, чтобы сделать некоторую задачу, которую вы хотите выполнить. Но вам нужно иметь возможность получить доступ к те «вещи, которые другие написали», чтобы сделать это. Это то, что Python’s Механизм импорта это для.

{‘dt’: [‘Импортировать’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-import-statement’}]}]}

{‘dd’: ‘Используется для привлечения функциональности внешнего модуля в свой собственный код.’}

Глагол с среднего английского импортировать , через старый французский от латыни Importare Отказ Общее значение состоит в том, чтобы «принести/нести [товары в эту страну] из-за рубежа». В вычислении значит приносить или Импортировать Некоторые функциональные возможности экспортируется по другой программе, написанной на одном языке в текущей программе.

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

import MODULE

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

import MODULE_A, MODULE_B

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

import (MODULE_A, MODULE_B)

Любое название внутри импортируемых модулей (ов) может быть доступно в вашей собственной программе, используя точка доступа Узор в форме модуля. Немейте. Так Например, если вы хотите получить окружность круга:

import math

radius = 3
circumference = math.tau * radius

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

{‘dt’: ‘от’}

{‘dd’: [‘Модифицирует’, ‘Импортировать’, ‘Чтобы позволить вам импортировать определенные имена из внешнего модуля.’]}

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

Это используется для модификации Импорт Чтобы импортировать определенное имя из модуля, а не Весь Модуль:

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

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

{‘dt’: ‘в виде’}

{‘dd’: [‘Модифицирует’, ‘Импортировать’, ‘Чтобы создать альтернативное имя (или псевдоним) для импортированного имени.’]}

От старого английского Eallswā Значит «просто так» или просто «все так», что делает его уменьшенной формой Также Отказ Использование здесь происходит от формы наречие, означающих «[действовать] таким образом или роль [некоторая вещь]». В Python это очень конкретно означает «[отсюда на ссылке к этой вещи] как [Это вместо] ».

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

import MODULE as MODULE_ALIAS
from MODULE import NAME as NAME_ALIAS

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

from math import pi as half_as_good_as_tau

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

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

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

{‘dt’: [‘поднимать’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-raise-statement’}]}]}

{‘dd’: [‘Используется для подразделения указанного исключения, который заставит программу немедленно остановиться и выйти, если не обрабатывается ан’, ‘Кроме’, ‘БЛОКИРОВАТЬ.’]}

Среднее английское слово с Многие Значения, но в этом случае он исходит от формы глагола, означающего «поднять вертикально, строить или строить» или «сделать выше». Значение в вычислениях более конкретно из более нового смысла «упомянуть [вопрос, проблему или аргумент] для обсуждения», как в «к поднять внимание [к вопросу]». В нескольких других языках программирования бросить используется с аналогичным смыслом.

Использование это Обычно собирается быть:

raise EXCEPTION

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

raise EXCEPTION from OTHER_EXCEPTION

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

Наконец внутри кроме БЛОКИРОВАТЬ Вы можете просто:

raise

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

Сигнализировать что конкретное состояние не выполнено

{‘dt’: [‘утверждать’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-assert-statement’}]}]}

{‘dd’: ‘Используется для проверки, если некоторое выражение считается верным, и если не поднять AssertionError.’}

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

Использование Утверждать Обычно будет в форме:

assert EXPRESSION

Который будет просто поднять AssertionError, если выражение не оценивает как Правда Отказ

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

assert EXPRESSION, "something is wrong!"

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

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

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

… за исключением того, что если -O Флаг был передан Утверждать Заявление будет просто заменено пройти И ничего не произойдет.

Чтобы поймать сигнал и реагировать на него

С обоими поднять и Утверждать В вашем инструменте вы знаете, как сигнализировать исключение, но как вы ловите и реагируете на (или игнорировать) один? Это где Обработка исключений Python Механизм вступает в игру.

{‘dt’: [‘пытаться’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#the-try-statement’}]}]}

{‘dd’: [‘Запускает блок обработчика исключений;’, {’em’: ‘должен’}, ‘следовать либо’, ‘Кроме’, ‘Блок, а’, ‘еще’, ‘блок или а’, ‘наконец-то’, ‘Блок для того, чтобы быть действительным синтаксисом.’]}

Глагол, заимствованный от старого французского слова Трир , что означает «тест», «эксперимент» или «попытка сделать». Значение в Python по существу одинаково, «[запуск A] тест [что-то, что май ошибка]».

{‘dt’: ‘Кроме’}

{‘dd’: [‘По выбору’, {’em’: ‘продолжается’}, ‘блок обработчика исключений путем укладки исключений; может ( и’, {’em’: ‘должен’}, ‘) ограничиваться определенными типами исключения. Более чем один из них может следовать’, ‘пытаться’, ‘и каждый будет проверяется в свою очередь, пока либо исключение не будет обрабатываться, либо не более’, ‘Кроме’, ‘заявления остаются.’]}

Глагол заимствован с средней французской Excepter и латынь Эксквой ; Оригинальное значение является «для получения», но тем более общим использование использует его «исключить [что-то]» или «объект к [что-то]», как в «каждый фрукт, кроме яблок». Значение в Python немного расплывчато, но можно рассматривать как «улов, захват или ловушку [исключение]». На самом деле на многих других языках поймать используется для той же цели; Питона кроме Это исключение из этого правила.

{‘dt’: ‘наконец-то’}

{‘dd’: [‘По выбору’, {’em’: ‘очищает’}, ‘блок обработчика исключений, чтобы обеспечить средство’, {’em’: ‘всегда’}, ‘Выполнение некоторого действия, было ли связано исключением или нет.’, {’em’: ‘Должен’}, ‘появляются после любого’, ‘Кроме’, ‘Блоки, которые присутствуют, а также необязательно’, ‘еще’, ‘Блок, если это тоже присутствует. Если нет’, ‘Кроме’, ‘Блок присутствует тогда’, ‘наконец-то’, {’em’: ‘должен’}, ‘завершить обработчик исключения.’]}

С среднего английского Финалы смысл «в конце или заключение» или просто «наконец». Это подразумевает самое последнее, что нужно сделать в последовательности, что и значение здесь.

Обработка исключений – это первое обстоятельство, которое вы столкнулись, в котором один блок Должен следует другой, и правила несколько сложнее, чем все, что вы еще видели. Например, есть Два разные Минимальный синтаксически действительный Формы обработчика исключений:

try:
    BLOCK
finally:
    STATEMENT

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

Вторая форма делает обрабатывать исключение:

try:
    BLOCK
except:
    STATEMENT

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

try:
    BLOCK
except EXCEPTION:
    STATEMENT

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

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

except EXCEPTION as NAME:
    STATEMENT

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

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

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

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

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

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

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

Однако это относительно редко, потому что утверждение отступа от еще Будет ли Только быть выполненным, когда внутри «Исключение» не было поднято внутри попробуйте БЛОКИРОВАТЬ и нет ломать , Продолжить или вернуть Заявления были встречены в нем.

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

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

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

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

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

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

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

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

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

{‘dt’: [‘лямбда’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/expressions.html#lambda’}]}]}

{‘dd’: [‘Используется для определения Callable’, {‘a’: [‘Анонимная функция’, {‘href’: ‘https://en.wikipedia.org/wiki/Anonymous_function’}]}, ‘и это’, {’em’: ‘подпись’}, ‘.’]}

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

Несмотря на имя a лямбда На самом деле на самом деле концептуально простейшая форма функции в Python, потому что вы можете подумать об этом как о способе создания выражения задержки-оценки, которое указано с определенной формой:

lambda : EXPRESSION

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

(lambda : EXPRESSION)()

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

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

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

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

Вот a лямбда С одним параметром:

lambda NAME: EXPRESSION

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

lambda NAME_A, NAME_B: EXPRESSION

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

(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)

Здорово! квадрат сейчас 4 и Прямоугольник это 15 ; У нас есть основа повторного использования кода!

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

Так как мы только что пошли и назначили, что должно быть анонимный (что означает «не имеет названия») функции для имени, давайте посмотрим, как мы должны Обычно Написать функции в Python.

Названные функции

назван Функция опирается на идеи лямбда но возьми их до Многое Более гибкое место, позволяющее легко повторно использовать большие куски кода. Они тоже немного более тонкие, потому что они не оценивают точно так же, как выражение. На самом деле по умолчанию они всегда будут оценивать Нет Если вы явно не скажете им сделать иначе.

{‘dt’: [‘деф’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#function-definitions’}]}]}

{‘dd’: [‘Используется для определения a’, {’em’: ‘название’}, ‘функция и ее’, {’em’: ‘подпись’}, ‘, Блок с отступом, который следует, затем можно повторно использовать, вызывая это имя, используя’, {‘code’: ‘Функция ()’}, ‘синтаксис.’]}

{‘dd’: [‘При использовании внутри’, ‘класс’, ‘определяет название’, {’em’: ‘метод’}, ‘вместо этого, который называется с помощью’, {‘code’: ‘Class.method ()’}, ‘синтаксис.’]}

{‘dd’: [‘Также может быть отмечен’, ‘async.’, ‘, чтобы начать’, ‘async def.’, ‘, увидеть ниже.’]}

Сокращение слова Определить , который поставляется через средний английский Deffinen от старых французских и латинских корней. Это глагол, который означает «указать или исправить [значение слова или фразы]». В Python он используется специально для создания именованного подпрограмма. На других языках Определить , FN , веселье , ФУНК , Функция и Пусть часто используются вместо этого.

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

def FUNCTION():
    STATEMENT

Это определяет функцию, которую можно назвать с помощью Функция () , который затем выполнит каждое утверждение внутри блока с отступом. Как вы можете видеть, что это концептуально эквивалентно «названному» лямбда Форма вы видели ранее. Сравните эти две формы:

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

И вы увидите, что они Очень похоже, кроме того, что def Версия может запустить произвольное количество утверждений ² Отказ

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

def FUNCTION(NAME):
    STATEMENT

И так же, как с лямбда Мы можем иметь несколько параметров:

def FUNCTION(NAME_A, NAME_B):
    STATEMENT

Которые давайте построим область Функция, которую мы сделали раньше с лямбда :

def area(width, height):
    width * height

square = area(2, 2)
rectangle = area(3, 5)

За исключением, подождите минуту … Разве я не говорил чуть выше этого def Функции оценивают в Нет Когда звонит? Да, прямо сейчас оба квадрат и Прямоугольник назначены Нет Отказ Мы рассчитали две области, но затем отбрасывайте их снова, как только Местный охват область закрыто. Теперь, как черт возьми, мы получаем область OUT площадь , так или иначе?

Остановите функцию и верните значение

{‘dt’: [‘возвращение’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-return-statement’}]}]}

{‘dd’: [‘Используется для немедленного отказа от контроля и окончания выполнения функции в точке, на которой он встречается. Если после выполнения выражения, которое оценивается в первую очередь, и полученный объект возвращается вызывающим абонентом функции. Если выражение не присутствует’, ‘Никто’, ‘возвращается вместо этого. Не имеет смысла вне функции, таким образом, если присутствует вообще Это’, {’em’: ‘должен’}, ‘быть внутри блока, который следует за’, ‘деф’, ‘.’]}

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

1. Непереходный смысл – «отдать обратно (или отказываться) контроль [к процедуру вызовов]«, как в «Когда функция выходит из этого, будет return Control».
2. Переходный смысл – «пройти [некоторые данные] обратно в процедуру вызовов», как в «эта функция будет return текущее время».

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

Самое простое использование вернуть немедленно заканчивает функцию и возвращает Нет к абонеру:

return

Эта форма относительно редко используется; Как упоминалось до функции всегда оценивает Нет по умолчанию; Таким образом, вы можете себе представить, что возвращение Является ли неявная последняя строка каждый функция.

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

return EXPRESSION

Который немедленно оценивает выражение и возвращает результирующий объект обратно к абонеру.

Вы также можете использовать вернуть Передать более одного объекта:

return EXPRESSION_A, EXPRESSION_B

Это оценивает каждое выражение в свою очередь, заканчивает функцию и возвращает кортеж (тип сбора фиксированной длины), содержащий один объект для каждого выражения.

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

Что вы заметите, что вернуть Захватывает функция на данный момент она оценивается. Ниже приведено ниже этой точки в функции, по существу не существует (с одним исключением, Наконец Блок внутри обработчика исключений). Итак, как бы вы справились с ситуациями, в которых вам нужно было вернуть данные, но продолжать работать потом?

Приостановить функцию и вернуть значение

{‘dt’: [‘урожай’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-yield-statement’}]}]}

{‘dd’: [‘Используется для немедленной паузы выполнения и временно отказаться от контроля в точке, на котором он встречается. В случае с последующей выражением, который оценивается в первую очередь, и полученный объект дает обратно к абонеру функции; Если выражение не присутствует’, ‘Никто’, ‘доносится вместо этого. Не имеет смысла вне функции, таким образом, если присутствует вообще Это’, {’em’: ‘должен’}, ‘использоваться внутри блока, который следует’, ‘деф’, ‘.’]}

Этимологически самое странное слово в этом списке; получает от среднего английского свидетельствовать И старый английский Гилл , оба из которых означают «платить» и поделиться своим корнем со старой норной Гжальд и немецкий Geld С оба из которых означают «деньги». Сегодня Geld означает древнюю форму вынужденного налога или выкупа, но это также означает «кастрата». Исторически Хэндз был налогом, поднятым на английском языке их королем. Этот налог был поднят для оплаты волн датских викингов, по-видимому, не кастрируйте английский (или, по крайней мере, их король). Ничего из этого здесь непосредственно важно, но может немного объяснить, почему значение в вычислениях происходит от обоих «для того, чтобы уступить и отказаться от контроля», как в « доходности к встречному движению», а также «возвращать [ Результатом или возврат инвестиций] «как в« Фонде имеет Урожай 5% в год ». В обоих случаях последствия состоит в том, что ситуация еще не окончательная, и, вероятно, повторяется: вы урожай Тогда ты ждешь, тогда ты доходность снова.

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

Использование доходность похож на вернуть :

yield

yield EXPRESSION

yield EXPRESSION_A, EXPRESSION_B

Однако любой Функция, которая использует доходность На самом деле возвращает особый вид коллекции, известный как генератор, когда вызывается. В отличие от обычной коллекции генератор не содержит всех своих элементов в памяти одновременно, но вместо этого «генерирует» каждый элемент, как требуется, запущенная через функцию до доходность встречается и дает предмет. Генератор приостанавливает выполнение в этой точке, позволяя код использовать генератор для работы с этим элементом. При желании он может запросить следующий элемент, в какой момент генератор продолжается к следующему доходность и так далее, пока нет больше доходность заявления осталось бежать или вернуть встречается.

Это то, что позволяет следую форму:

yield from GENERATOR

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

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

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

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

На самом простом пространство имен – это, по сути, просто место, где Python сохраняет любое название, которое вы создаете, поэтому они используются всякий раз, когда Python должен посмотреть объект, упомянутый этим именем. Каждое пространство имен имеет Область , который ограничивает, как долго проспевочное пространство «живет» и какое-либо название внутри него является читаемый и/или Пирена данным заявлением. Пространства имен образуют иерархию, однако, поэтому правила могут быть немного сложными для запоминания.

В любом данном пространстве имен заявление может:

1. оба читать и Напишите любое имя, определенное в своем собственном пространстве имен
2. читать , но не Напишите любое имя, определенное в приложении родитель пространство имен
3. ни один читать ни Напишите любое имя, определенное в брат или Ребенок пространство имен

На верхнем уровне есть собственное пространство Python, которое содержит все Встроенный Имена, которые Python предоставляет вам. Это пространство имен не может Будьте написаны, и любое имя в нем по сути живет навсегда.

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

Далее каждый вызываемый вы создаете, получает свой уникальный Местный пространство имен Когда это называется ; Любое название, созданное здесь, живет только до тех пор, пока вызываемый работает, и когда он заканчивает как название, так и объект, который он относится к уничтожению, если только вернуть или доходность используется, чтобы передать его обратно в объем вызова.

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

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

Но использовать Из имени немного менее очевидно: при использовании в операторе Python первые поиски имени в непосредственной близости от Местный сфера. Если он не может найти имя, то он ищет немедленного родителя (известный как нелокальный ) область применения, а затем он продолжает поиск каждой последовательной родительской области до тех пор, пока он не найдет имя, либо не сможет разрешить его и ошибки.

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

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

Напишите на вершину из любой точки

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

{‘dt’: [‘Глобальный’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-global-statement’}]}]}

{‘dd’: [‘Используется для объявления имени как часть’, {’em’: ‘Глобальный’}, ‘пространство имен; название’, {’em’: ‘может нет’}, ‘были использованы ранее в том же пространстве имен. В действительности это позволяет’, {’em’: ‘местный’}, ‘Оператор для создания и назначения’, {’em’: ‘Глобальный’}, ‘Имя в противном случае можно было только прочитать.’, {’em’: ‘Может’}, ‘использоваться в глобальном пространстве имен, но не имеет никакого эффекта.’]}

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

Использование довольно просто; Основное ограничение состоит в том, что оно не может появиться после Имя было использовано:

global NAME
NAME = EXPRESSION

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

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

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

{‘dt’: [‘нелокальный’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-nonlocal-statement’}]}]}

{‘dd’: [‘Используется исключительно внутри’, {’em’: ‘вложенный’}, ‘Функции/методы (также известны как’, {’em’: ‘замыкание’}, ‘) связать’, {’em’: ‘Предварительно существует’}, ‘Имя в’, {’em’: ‘родитель’}, “‘s пространство имен. Это позволяет ребенку выступление, чтобы получить доступ к записи, определенному в своем родиве.”, {’em’: ‘Должен’}, ‘появляются до любой ссылки на это имя в локальном объеме.’]}

Прилагательное, образованное путем объединения префикса не («Не») и Местный («Относительно определенного места»). Это в первую очередь научно-технические неологизм (буквально «новое слово»), которое не имеет истинного общего значения, только конкретные значения в пределах определенных полей. В программировании это означает не локальная переменная , что означает «[имя, которое] доступно ни на локальный ни Global пространство имен”. В Python он очень конкретно применяется к пространству имен охватывающей функции с точки зрения вложенной функции, а также является также ключевое слово, которое связывает Местный Имя в этой вложенной функции в нелокальный пространство имен, позволяющее ему быть Пирена изнутри вложенной функции.

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

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

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

Убить его огнем

Так что вы видели, как Добавить Имя на пространство имен, но как вы Удалить Имя из пространства имен?

{‘dt’: [‘дель’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/simple_stmts.html#the-del-statement’}]}]}

{‘dd’: ‘Используется для удаления имени (или имена) из пространства имен; Если никаких других ссылок не существует для объекта, которое называется именем, базовый объект также удаляется.’}

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

Наиболее распространенное использование является предоставление единого названия:

del NAME

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

del NAME_A, NAME_B, NAME_C

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

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

global NAME
del NAME

Вы также можете использовать дель Чтобы удалить атрибуты объектов и членов (ов) коллекций, однако, что на самом деле происходит, зависит от типа объекта/коллекции. Список Сбор, например, позволяет использовать дель Удалить как индивидуальный индексы и Ломтики его содержимого:

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

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

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

До этого момента я был довольно расплывчатым о том, что на самом деле объект. В Объектно-ориентированное программирование Парадигма, также известная как OOP, объект, в основном, A вещь что имеет оба Государство (в виде именованных атрибуты ) и поведение (В форме Callable Методы ). Две отдельные вещи того же Тип Может иметь разные конкретные значения для этих атрибутов – мы называем их разными экземпляры того же Тип – Но они разделяют один и тот же общий интерфейс . Однако ему немного больше, чем это; Программист должен быть в состоянии определить частичные интерфейсы, которые мы позвоним Черты Этот типы с подобными потребностями могут реализовывать по-разному, так что они все разделяют некоторые общие атрибуты и поведение (свойство, известное как полиморфизм ). Кроме того, эти черты должны быть в состоянии пропустить из более общих типов на более специфические типы через наследство Механизм, так как родитель проходит на черты своих детей.

Вы можете привести пример от природы; Утка – это тип птицы, и она наследует определенные черты, которые он акции будут все птицами. Все птицы – это тип животных, и, таким образом, наследует определенные черт, общие будут все животные. Животное – это вид жизни, и так далее. Таким образом, Howard, определенная утка, имеет все атрибуты и поведение жизни, животных, птиц и уток, все хорошо свернули в одном экземпляре типа утки.

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

{‘dt’: [‘класс’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#class-definitions’}]}]}

{‘dd’: ‘Используется для определения шаблона для нового типа объекта.’}

Существительное заимствовало через французский CLASSE от латыни Classis , Что означало «подразделение, армию, флота», «народ Рима под вооружением», и, странно конкретно, «любым из шести порядков, в которых слуги Туллиус разделил римских людей с целью налогообложения», который идет Долгий путь к объяснению, почему английский – это сложный язык для освоения. Тем не менее, общий смысл, который мы здесь используем, безусловно, озаимствованы из эволюционной таксономии, подразумевая «группу, которая разделяет некоторые наследуемые признаки». Специфическое значение в Python исходит из объектно-ориентированного программирования и подразумевает «шаблон для создания объектов, которые имеют общий наследуемый государство (атрибуты) и поведение (методы)».

В Python вы определяете новый тип, создав новое имя, которое также является Callable; Отныне мы назовем это класс. класс Ключевое слово используется для запуска нового блока, который определяет Реализация этого класса:

class CLASS:
    pass

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

NAME = CLASS()

Теперь из вышесказанного вы можете ожидать, что именно есть нет атрибуты или поведение, но на самом деле у него есть минимальный Интерфейс, который доля всех объектов (его можно напечатать и использовать в сравнениях, например, хотя и не очень полезно). Это получает это, потому что все Новый класс Определения неявно наследуют от объект , который является Питоном базовый тип .

Вы также можете указать более общий класс (также известный как Superclass ), чтобы наследовать от:

class CLASS(SUPERCLASS):
    pass

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

class CLASS(SUPERCLASS_A, SUPERCLASS_B):
    pass

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

Просто определяя класс и его суперкласс, не придавая ему каких-либо атрибутов и методов самого своего необычного, так что вы Обычно Смотрите как минимум пользовательский Инициализатор Метод, который по Конвенции делается путем определения специального Двойной подчеркивает (или «дубли») Метод экземпляра __init__ :

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

Как вы можете видеть, что метод экземпляра – это просто еще один вид определения функции, используемый с использованием def Отказ На самом деле метод – это просто функция, которая была добавлена в пространство имен класса. Это верно, класс Ключевое слово также создает новый вид локального пространства имен, этот остается прикреплен к классу и позволяет просматривать имена на либо экземпляр или сам класс, используя точка доступа экземпляр шаблонов.Name и Class.name. Обратите внимание на Я Название параметра в определении метода выше? Это имя, данное Конвенцией к Первый Параметр любого метода экземпляра, и это то, как вы получаете доступ к атрибутам, установленным на самом экземпляре.

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

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)

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

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

Так как они фундаментальный строительный блок все в Python’s Модель данных , есть Лот Чем можно сказать О классах в Python И есть много тонкостей, которые могут попасть в их правильное использование (и неправильное оскорбление), поэтому мы часто вернемся к ним часто в более поздних статьях в этой серии. Теперь, хотя важная вещь – начать признавать, как класс Используется для их создания и как экземпляры используются при доступе к их атрибутам и методам. Также полезно знать, что существует довольно много методов «Dunder», и что они используются для реализации большого количества общего «недостаточности» функциональности, которая поддерживает все Встроенные функции Мы начнем встретиться в более поздних статьях.

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

Иногда есть действия, которые вы всегда Хотите выполнить в определенном контексте, например, совершение транзакции базы данных или закрытие сетевого подключения. Эти вещи Обычно включать в себя некоторую форму Обработка исключений или другая котельная, специфичная для задачи, и это может привести к большому количеству котельной, которая должна быть повторена. Примером является что-то простое, как прочитать файл: Открытие файла обязательно должно означать получение некоторых ресурсов из основной операционной системы, и вы всегда хотите освободить эти ресурсы, даже если вы случайно пытались открыть файл, который не существовал Или у вас не было разрешений для чтения. Файл – это Тип Объекта, который всегда будет нести этот контекстуальный необходимость управлять ресурсом с ним, и поэтому вам нужно будет написать то же самое пытаться и Наконец Котельная каждый время вы открываете файл.

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

{‘dt’: [‘с участием’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#the-with-statement’}]}]}

{‘dd’: [‘Начинается а’, {‘a’: [{’em’: ‘Менеджер контекста’}, {‘href’: ‘https://docs.python.org/3/reference/datamodel.html#context-managers’}]}, ‘Блок, который гарантирует, что отступные операторы (ы) ниже его выполняются в контексте управляемого объекта.’]}

Предложение среднего английского, которое забирает свое произношение из одного старого английского термина, Wið («против»), но принимает свое современное значение от другого, середина («В связи с«), который, в свою очередь, происходит от немецкого мит . Значение в Python проистекает из в пределах , значение «Внутри масштаба или контекста [некоторая вещь или событие]».

Любое использование с требует выражения, которое оценивает объект, который удовлетворяет Диспетчер контекста Тип Интерфейс, и, таким образом, внедрил как __enter__ и __exit__ «Дундер» методы. Отныне мы позвоним это выражением A Context_manager, чтобы сделать примеры яснее.

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

with CONTEXT_MANAGER:
    STATEMENT

Который войдет в контекст, позвонив Context_manager. __enter__ () , выполните оператор в контексте, а затем выйти из контекста, позвонив Context_manager. __exit__ () Отказ

Но чаще всего вы хотите использовать как Чтобы назначить объект, возвращенный Context_manager. __enter__ () на имя псевдонима, поэтому блок может работать с ним:

with CONTEXT_MANAGER as NAME:
    STATEMENT

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

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

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

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

Иногда вы хотите работать в течение более чем одного context_manager:

with CONTEXT_MANAGER_A as NAME_A, CONTEXT_MANAGER_B as NAME_B:
    STATEMENT

Который работает точно так же, как гнездовая с внутри другого:

with CONTEXT_MANAGER_A as NAME_A:
    with CONTEXT_MANAGER_B as NAME_B:
        STATEMENT

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

И наконец … два для работы асинхронно

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

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

Асинхронное программирование – это продвинутая тема, которая является справедливой специализированной, поэтому, используя его хорошо за пределами объема этой серии. Это также довольно новое дополнение к языку, и его использование колебалось от версии к версии. Вместо того, чтобы попытаться обобщить тех, кто изменился, я просто буду описать самые основы использования этих ключевых слов в Python 3.7 ниже. Если, однако, вам любопытно, есть Недостойкий async Primer, доступный здесь это, кажется, поддерживается в курсе.

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

{‘dt’: [‘async.’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/compound_stmts.html#coroutine-function-definition’}]}]}

{‘dd’: [‘Используется для отмены другого ключевого слова в качестве того, что работает асинхронно. Как таковой,’, ‘async.’, {’em’: ‘может нет’}, ‘появляются самостоятельно.’]}

{‘dd’: [‘С участием’, ‘деф’, ‘в виде’, ‘async def.’, ‘Определить асинхронную функцию, также известную как COROUTINE.’]}

{‘dd’: [‘С участием’, ‘за’, ‘в виде’, ‘асинхн’, ‘петлю над’, {’em’: ‘асинхронный итератор’}, ‘внутри АН’, ‘async def.’, ‘.’]}

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

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

async KEYWORD

Однако, в отличие от других любого другого ключевого слова, которое мы видели, использование async Будет ли всегда Начните с определения нового Corotine:

async def COROUTINE():
    STATEMENT

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

Например, вы можете использовать async для Петлю на асинхронный итератор такие как генератор COROUTINE (который просто COROUTINE, который использует доходность вместо вернуть ).

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

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

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

Практически каждый Ciboutine должен будет дождаться других Coroutine (ы), поэтому есть другое ключевое слово, которое можно использовать только в пределах async def Отказ

{‘dt’: [‘Ждите’, ”, {‘a’: [‘🗎’, {‘href’: ‘https://docs.python.org/3/reference/expressions.html#await-expression’}]}]}

{‘dd’: [‘Используется для приостановки выполнения Corotine нашлось’, {’em’: ‘в пределах’}, ‘и ждет, чтобы Coroutine к его праву завершить; можно использовать только внутри’, ‘async def.’, ‘.’]}

С среднего английского глагола Ожидается («ждать») от старого французского engier / Agaitier («Лежать в ожидании, смотреть или наблюдать»). Общий смысл более активным и враждебным, чем ждать , который это модификация. В асинхронном программировании это означает «[приостановить исполнение] и подождать [для чего-то до конца]».

ждать Ключевое слово всегда будет использоваться для вызова COROUTINE внутри async def :

async def OUTER_COROUTINE():
    await COROUTINE()

Что приостановит выполнение внешнего COROUTINE и ждать до под названием Coroutine, в конечном итоге, возвращает контроль. Любое значение, возвращаемое под названием COROUTINE, пропускается через Ждите , чтобы вы могли думать о await Corotine () как асинхронное выражение, которое будет, в конце концов Оцените любой, как позвоновается, когда он возвращается.

Конечно, теперь, когда у вас есть основы выполнения асинхронной работы вниз, как вы на самом деле Выполнить Такая работа? Ну, поскольку Python 3.7, который все еще требует использования функциональности, предоставляемых асинсио Модуль, детали которых являются хорошо за пределами объема этих статей. Смотрите async primer. Я упомянул ранее для деталей.

Whew …

Там у вас их, python’s 35 ключевых слов: в и из себя не хватает, чтобы вы свободно говорить в Python, но если вы прочитали это далеко и переварили его, вы хорошо на пути к по-настоящему Понимание (а не просто Использование ) Скелет что здесь происходит В одном из самых быстро растущих общих языков программирования вокруг. В следующем посту в этой серии мы сделаем шаг от слова и смотри вместо этого на Символы , с погружением в питону чуть меньше, но, к счастью Многое проще, список Операторы Отказ

1. Существует 35 ключевых слов в виде Python 3.7, текущей основной версии языка на момент написания. Новые ключевые слова добавлены довольно редко, и ключевым словам еще реже, но в любой версии вы можете использовать от ключевого слова Import KWLIST; Печать (KwList) Для просмотра текущего списка. ↩

2. Положить def на одной строке делает эквивалентность с лямбда Более очевидно, но ради читабельности не делай это очень часто. ↩

Оригинал: “https://dev.to/yawpitch/the-35-words-you-need-to-python-13pe”