Список ключевых слов в Python

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

Список всех ключевых слов программирования Python:

False	await	else	import	pass
None	break	except	in	raise
True	class	finally	is	return
and	continue	for	lambda	try
as	def	from	nonlocal	while
assert	del	global	not	with
async	elif	if	or	yield

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

>>> import keyword
>>> print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Описание ключевых слов Python с примерами

True, False

True и False — значения истины в Python. Это результаты операций сравнения или логических (булевых) операций в Python. Например:

>>> 1 == 1
True
>>> 5 > 3
True
>>> True or False
True
>>> 10 <= 1
False
>>> 3 > 7
False
>>> True and False
False

Здесь видно, что первые три выражения истинны, поэтому интерпретатор возвращает True, и возвращает False для остальных трёх. True и False в Python — это то же самое, что 1 и 0. Это можно подтвердить следующим примером:

>>> True == 1
True
>>> False == 0
True
>>> True + True
2

None

None — специальная константа в Python, представляющая отсутствие значения или нулевое значение.

Это объект собственного типа данных NoneType. Мы не можем создать несколько объектов None, но можем присвоить его переменным. Эти переменные будут равны друг другу.

Нужно понимать, что None не означает False, 0 или пустой список, словарь, строку и так далее. Например:

>>> None == 0
False
>>> None == []
False
>>> None == False
False
>>> x = None
>>> y = None
>>> x == y
True

Функции, не возвращающие ничего, автоматически возвращают объект None. None также возвращается функциями, в которых поток выполнения программы не встречает оператор return. Например:

def a_void_function():
    a = 1
    b = 2
    c = a + b

x = a_void_function()
print(x)

Вывод

None

В этой программе есть функция, не возвращающая значение, хотя она выполняет некоторые операции внутри. Поэтому, когда мы печатаем x, мы получаем None, который возвращается автоматически (неявно). Аналогично, ещё один пример:

def improper_return_function(a):
    if (a % 2) == 0:
        return True

x = improper_return_function(3)
print(x)

Вывод

None

Хотя у этой функции есть оператор return, он достигается не в каждом случае. Функция вернёт True только тогда, когда вход чётный.

Если мы передадим функции нечётное число, None возвращается неявно.

and, or, not

and, or, not — логические операторы в Python. and даст True только если оба операнда True. Таблица истинности для and:

A	B	A and B
True	True	True
True	False	False
False	True	False
False	False	False

or даст True, если любой из операндов True. Таблица истинности для or:

A	B	A or B
True	True	True
True	False	True
False	True	True
False	False	False

Оператор not используется для инвертирования значения истины. Таблица истинности для not:

A	not A
True	False
False	True

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

>>> True and False
False
>>> True or False
True
>>> not False
True

as

as используется для создания псевдонима при импорте модуля. Это означает присвоение другого имени (пользовательского) модулю при его импорте.

Например, в Python есть стандартный модуль math. Допустим, мы хотим вычислить, что такое косинус пи, используя псевдоним. Мы можем сделать это так:

>>> import math as myAlias
>>> myAlias.cos(myAlias.pi)
-1.0

Здесь мы импортировали модуль math, дав ему имя myAlias. Теперь мы можем обращаться к модулю math с этим именем. Используя это имя, мы вычислили cos(pi) и получили -1.0.

assert

assert используется в целях отладки.

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

Если условие истинно, ничего не происходит. Но если условие ложно, поднимается AssertionError. Например:

>>> a = 4
>>> assert a < 5
>>> assert a > 5
Traceback (most recent call last):
  File "<string>", line 301, in runcode
  File "<interactive input>", line 1, in <module>
AssertionError

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

>>> a = 4
>>> assert a > 5, "The value of a is too small"
Traceback (most recent call last):
  File "<string>", line 301, in runcode
  File "<interactive input>", line 1, in <module>
AssertionError: The value of a is too small

В этой точке мы можем отметить, что

assert condition, message

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

if not condition:
    raise AssertionError(message)

async, await

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

import asyncio

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('world')

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

asyncio.run(main())

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

Здесь сначала выводится Hello. Ключевое слово await заставляет программу ждать 1 секунду. А затем выводится world.

break, continue

break и continue используются внутри циклов for и while для изменения их обычного поведения.

break завершит самый малый цикл, в котором находится, и управление переходит к оператору сразу после цикла. continue вызывает завершение текущей итерации цикла, но не всего цикла.

Это можно проиллюстрировать следующими двумя примерами:

for i in range(1,11):
    if i == 5:
        break
    print(i)

Вывод

1
2
3
4

Здесь цикл for намеревается вывести числа от 1 до 10. Но условие if выполняется, когда i равен 5, и мы выходим из цикла. Таким образом, выводятся только числа от 1 до 4.

for i in range(1,11):
    if i == 5:
        continue
    print(i)

Вывод

1
2
3
4
6
7
8
9
10

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

class

class используется для определения нового пользовательского класса в Python.

Класс — это коллекция связанных атрибутов и методов, пытающихся представить реальную ситуацию. Идея помещения данных и функций вместе в класс является центральной для концепции объектно-ориентированного программирования (ООП).

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

class ExampleClass:
    def function1(parameters):
        …
    def function2(parameters):
        …

def

def используется для определения пользовательской функции.

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

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

def function_name(parameters):
    …

del

del используется для удаления ссылки на объект. В Python всё — объект. Мы можем удалить ссылку переменной с помощью del.

>>> a = b = 5
>>> del a
>>> a
Traceback (most recent call last):
  File "<string>", line 301, in runcode
  File "<interactive input>", line 1, in <module>
NameError: name 'a' is not defined
>>> b
5

Здесь видно, что ссылка на переменную a была удалена. Поэтому она больше не определена. Но b всё ещё существует.

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

>>> a = ['x','y','z']
>>> del a[1]
>>> a
['x', 'z']

if, else, elif

if, else, elif используются для условного ветвления или принятия решений.

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

def if_example(a):
    if a == 1:
        print('One')
    elif a == 2:
        print('Two')
    else:
        print('Something else')

if_example(2)
if_example(4)
if_example(1)

Вывод

Two
Something else
One

Здесь функция проверяет вводимое число и выводит результат, если оно 1 или 2. Любой другой ввод вызовет выполнение части кода else.

except, raise, try

except, raise, try используются с исключениями в Python.

Исключения — это, по сути, ошибки, указывающие, что что-то пошло не так при выполнении программы. IOError, ValueError, ZeroDivisionError, ImportError, NameError, TypeError и так далее — несколько примеров исключений в Python. Блоки try...except используются для перехвата исключений в Python.

Мы можем явно поднять исключение с помощью ключевого слова raise. Пример:

def reciprocal(num):
    try:
        r = 1/num
    except:
        print('Exception caught')
        return
    return r

print(reciprocal(10))
print(reciprocal(0))

Вывод

0.1
Exception caught
None

Здесь функция reciprocal() возвращает обратное от вводимого числа.

Когда мы вводим 10, мы получаем обычный вывод 0.1. Но при вводе 0 автоматически поднимается ZeroDivisionError.

Это перехватывается нашим блоком try…except, и мы возвращаем None. Мы могли бы также явно поднять ZeroDivisionError, проверив ввод, и обработать его в другом месте так:

if num == 0:
    raise ZeroDivisionError('cannot divide')

finally

finally используется с блоком try…except для закрытия ресурсов или файловых потоков.

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

try:
    Try-block
except exception1:
    Exception1-block
except exception2:
    Exception2-block
else:
    Else-block
finally:
    Finally-block

Здесь, если в Try-block есть исключение, оно обрабатывается в блоке except или else. Но независимо от порядка выполнения, мы можем быть уверены, что Finally-block будет выполнен, даже если есть ошибка. Это полезно при очистке ресурсов.

for

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

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

names = ['John','Monica','Steven','Robin']
for i in names:
    print('Hello '+i)

Вывод

Hello John
Hello Monica
Hello Steven
Hello Robin

from, import

Ключевое слово import используется для импорта модулей в текущее пространство имён. from…import используется для импорта конкретных атрибутов или функций в текущее пространство имён. Например:

import math

импортирует модуль math. Теперь мы можем использовать функцию cos() внутри него как math.cos(). Но если бы мы хотели импортировать только функцию cos(), это можно сделать с помощью from:

from math import cos

теперь мы можем использовать функцию просто как cos(), без необходимости писать math.cos().

global

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

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

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

Следующий пример поможет это прояснить.

globvar = 10
def read1():
    print(globvar)
def write1():
    global globvar
    globvar = 5
def write2():
    globvar = 15

read1()
write1()
read1()
write2()
read1()

Вывод

10
5
5

Здесь функция read1() просто читает значение globvar. Поэтому нам не нужно объявлять её как global. Но функция write1() изменяет значение, поэтому нам нужно объявить переменную как global.

В нашем выводе видно, что изменение произошло (10 изменилось на 5). write2() также пытается изменить это значение. Но мы не объявили его как global.

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

in

in используется для проверки, содержит ли последовательность (список, кортеж, строка и так далее) значение. Возвращает True, если значение присутствует, иначе возвращает False. Например:

>>> a = [1, 2, 3, 4, 5]
>>> 5 in a
True
>>> 10 in a
False

Вторичное использование in — проход по последовательности в цикле for.

for i in 'hello':
    print(i)

Вывод

h
e
l
l
o

is

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

Возвращает True, если объекты идентичны, и False, если нет.

>>> True is True
True
>>> False is False
True
>>> None is None
True

Мы знаем, что в Python существует только один экземпляр True, False и None, поэтому они идентичны.

>>> [] == []
True
>>> [] is []
False
>>> {} == {}
True
>>> {} is {}
False

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

>>> '' == ''
True
>>> '' is ''
True
>>> () == ()
True
>>> () is ()
True

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

lambda

lambda используется для создания анонимной функции (функции без имени). Это встроенная функция, не содержащая оператор return. Она состоит из выражения, которое оценивается и возвращается. Например:

a = lambda x: x*2
for i in range(1,6):
    print(a(i))

Вывод

2
4
6
8
10

Здесь мы создали встроенную функцию, удваивающую значение, с помощью оператора lambda. Мы использовали её для удвоения значений в списке, содержащем числа от 1 до 5.

nonlocal

Использование ключевого слова nonlocal очень похоже на использование ключевого слова global. nonlocal используется для объявления того, что переменная внутри вложенной функции (функции внутри функции) не является локальной, то есть находится во внешней охватывающей функции. Если нам нужно изменить значение нелокальной переменной внутри вложенной функции, мы должны объявить её с nonlocal. Иначе внутри вложенной функции создаётся локальная переменная с этим именем. Следующий пример поможет это прояснить.

def outer_function():
    a = 5
    def inner_function():
        nonlocal a
        a = 10
        print("Inner function: ",a)
    inner_function()
    print("Outer function: ",a)

outer_function()

Вывод

Inner function:  10
Outer function:  10

Здесь inner_function() вложена в outer_function.

Переменная a находится в outer_function(). Поэтому, если мы хотим изменить её в inner_function(), мы должны объявить её как nonlocal. Обратите внимание, что a не является глобальной переменной.

Следовательно, мы видим из вывода, что переменная была успешно изменена внутри вложенной inner_function(). Результат без использования ключевого слова nonlocal:

def outer_function():
    a = 5
    def inner_function():
        a = 10
        print("Inner function: ",a)
    inner_function()
    print("Outer function: ",a)

outer_function()

Вывод

Inner function:  10
Outer function:  5

Здесь мы не объявляем, что переменная a внутри вложенной функции — nonlocal. Следовательно, создаётся новая локальная переменная с тем же именем, но нелокальная a не изменяется, как видно в нашем выводе.

pass

pass — это нулевой оператор в Python. При его выполнении ничего не происходит. Он используется как заполнитель.

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

def function(args):

в середине программы вызовет IndentationError. Вместо этого мы создаём пустое тело с оператором pass.

def function(args):
    pass

То же самое можно сделать и в пустом class.

class example:
    pass

return

Оператор return используется внутри функции для её выхода и возврата значения.

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

def func_return():
    a = 10
    return a

def no_return():
    a = 10

print(func_return())
print(no_return())

Вывод

10
None

while

while используется для циклов в Python.

Операторы внутри цикла while продолжают выполняться, пока условие для цикла while не оценится в False или не встретится оператор break. Следующая программа иллюстрирует это.

i = 5
while(i):
    print(i)
    i = i - 1

Вывод

5
4
3
2
1

Обратите внимание, что 0 равно False.

with

Оператор with используется для обёртывания выполнения блока кода методами, определёнными менеджером контекста.

Менеджер контекста — это класс, реализующий методы __enter__ и __exit__. Использование оператора with гарантирует, что метод __exit__ вызывается в конце вложенного блока. Эта концепция аналогична использованию блока try…finally. Вот пример.

with open('example.txt', 'w') as my_file:
    my_file.write('Hello world!')

Этот пример пишет текст Hello world! в файл example.txt. Файловые объекты имеют методы __enter__ и __exit__, определённые внутри них, поэтому они действуют как собственный менеджер контекста.

Сначала вызывается метод __enter__, затем выполняется код внутри оператора with, и наконец вызывается метод __exit__. Метод __exit__ вызывается, даже если есть ошибка. Это в основном закрывает файловый поток.

yield

yield используется внутри функции как оператор return. Но yield возвращает генератор.

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

>>> g = (2**x for x in range(100))

создаст генератор g, который генерирует степени 2 вплоть до числа, равного двум в 99-й степени. Мы можем генерировать числа с помощью функции next(), как показано ниже.

>>> next(g)
1
>>> next(g)
2
>>> next(g)
4
>>> next(g)
8
>>> next(g)
16

И так далее… Этот тип генератора возвращается оператором yield из функции. Вот пример.

def generator():
    for i in range(6):
        yield i*i

g = generator()
for i in g:
    print(i)

Вывод

0
1
4
9
16
25

Здесь функция generator() возвращает генератор, который генерирует квадрат чисел от 0 до 5. Это выводится в цикле for.