Ключевые (зарезервированные) слова в Python

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

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

  • False
  • None
  • True
  • and
  • as
  • assert
  • 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

Сам список можно получить при помощи следующего кода:

>>> import keyword
>>> print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', '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']

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

True и False

True и False - представители булевых (логических) операторов в Python, обозначают истину или ложь, если говорить дословным языком.

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

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

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

 

None

None - это специальная константа в Python, которая обозначает отсутствие значения или переменной, либо нулевое значение (не путать с числовым значением 0).

По сути это самостоятельный объект собственного типа NoneType. Стоит помнить, что мы не можем создать несколько None-объектов, но можем присвоить значение None переменным, при этом эти переменные будут между собой равны.

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

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

Данный пример содержит функцию, которая не возвращает никакого значения, несмотря на то, что производит некоторые операции внутри себя. Таким образом, когда мы выводим мы получаем None, возвращаемый по умолчанию. Ещё один пример:

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

x = improper_return_function(3)
print(x)  # None

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

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

andornot - логические операторы в Python. 

and вернёт True, только если оба операнда True.

Таблица возвращаемых значения для and 

ABA and B
TrueTrueTrue
TrueFalseFalse
FalseTrueFalse
FalseFalseFalse

 

or вернёт True, если один из операндов имеет значение True

Таблица возвращаемых значения для or

ABA and B
TrueTrueTrue
TrueFalseTrue
FalseTrueTrue
FalseFalseFalse

 

Оператор not используется для обращения булевых значений.

Таблица возвращаемых значения для not

Anot A
TrueFalse
FalseTrue

 

Небольшой пример использования операторов:

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

 

as

as используется для создания псевдонима во время импорта модуля, то есть позволяет определить имя импортируемому модулю.

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

В пример выше мы импортировали модуль math и присвоили ему псевдоним myAlias. Таким образом в контексте данного файла модуль math будет доступен под алиасом myAlias.

assert

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

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

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

Хотелось бы отметить, что чаще всего assert используется при написании тестов. Думаю причины понятны.

break, continue

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

break прервёт текущий цикл полностью и переведёт фокус интерпретатора на исполнение кода, расположенного сразу под телом цикла. continue завершит текущую итерацию и начнёт новую, при условии, что итератор содержит элементы после текущего.

for i in range(1,11):
    if i == 5:
        break
    print(i)
# Output
> 1
> 2
> 3
> 4

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

Посмотрим каким будет поведение с оператором continue.

for i in range(1,11):
    if i == 5:
        continue
    print(i)
# Output
> 1
> 2
> 3
> 4
> 6
> 7
> 8
> 9
> 10

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

class

class используется для объявления классов в коде.

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

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

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

 

def

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

Метод - это блок объединенных операторов, выполняющий определенную задачу. Методы помогают разбивать код на логические куски, что улучшает читабельность кода. Также методы облегчают выполнение повторяющихся процессов (DRY - Don't Repeat Yourself).

def function_name(parameters):
    …

 

del

del используется для удаления ссылки на Python-объект, находящийся в памяти. 

>>> 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, а само имя переменной после удаления значения было высвобождено. Но это тема отдельного разговора).

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

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

 

Операторы if, else, elif

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

Когда мы хотим проверить некоторое условие и выполнить код, основанный на значении проверяемого условия, то мы используем операторы if и elif. elif - короткое написание для конструкции else if. else выполняется, только если предыдущие логические операторы равны False

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)

# Output
> Two
> Something else
> One

 

except, raise, try

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

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

Также мы можем вызвать исключение при помощи оператора raise:

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

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

# Output
> 0.1
> Exception caught
> None

Когда мы передаём в функцию 10, в ответ мы получаем 0.1. Но если передать 0, то мы получим исключение ZeroDivisionError. Данное исключение отлавливается конструкцией try...except и поэтому мы получаем None. Также можно явным образом обрабатывать исключения, проверяя данные и вызывая исключения в нужных местах кода. Например:

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 интерпретатор перейдёт к блокам except и else. Но независимо от того, в каком порядке будут выполняться конструкции (и будут ли некоторые из них выполняться вообще) до finally, сам блок finally будет выполнен в любом случае. Это полезно для очистки ресурсов, закрытия открытых файлов, очистки пространства имён и т.п.

for

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

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

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

 

from и import

import используется для импортирования модулей в текущий модуль. from ... import ... используется для импорта определённого объекта Python.

# импортирует весь модуль math в текущий модуль
import math
# использование функции из модуля math
...
math.cos(...)
...

# импортирует функцию cos() из модуля math
from math import cos
# использование функции
...
cos(...)
...

 

global

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

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

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

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

# Output
> 10
> 5
> 5

 

in

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

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

Ещё одно применение in состоит в итерировании по последовательности в for-цикле:

for i in 'hello':
    print(i)
# Output
> h
> e
> l
> l
> o

 

is

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

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

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

Мы уже знаем, что в Python существует только по одному объекту True, False и None, таким образом:

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

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

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

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

lambda

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

a = lambda x: x*2
for i in range(1,6):
    print(a(i))
# Output
> 2
> 4
> 6
> 8
> 10

В примере выше была создана лямбда-функция, которая возвращает умноженное на 2 значение, которое было принято в качестве аргумента.

nonlocal

Использование nonlocal очень схоже с globalnonlocal используется для объявления переменной внутри вложенной функции (функции внутри функции) и указания, что данная переменная доступна и в родительской функции. Пример, как всегда, будет нагляднее витиеватых попыток объяснить смысл.

# использование 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()

# Output
> Inner function:  10
> Outer function:  10


# без использования nonlocal
def outer_function():
    a = 5
    def inner_function():
        a = 10
        print("Inner function: ",a)
    inner_function()
    print("Outer function: ",a)

outer_function()

# Output
> Inner function:  10
> Outer function:  5

 

pass

pass - это "нулевое" выражение в Python. Когда интерпретатор выполняет pass ничего не происходит. Зачастую используется в качестве "наполнителя". 

К примеру, мы объявили функцию, но не приступили к её написанию по различным причинам. В таком случае мы можем использовать pass:

def function(args):
    pass

Стоит помнить, что если мы объявим функцию, но её тело будем пустым

def function(args):

, то мы получим IndentationError

Тоже самое мы можем применить и к классам:

class Example:
    pass

 

return

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

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

def func_return():
    a = 10
    return a

def no_return():
    a = 10

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

# Output
> 10
> None

 

while

while используется для создания циклов, наряду с for ... in...

Код внутри цикла 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...except.

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

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

yield

yield используется внутри функций с той же целью, что и return. С одним отличием - yield возвращает генератор.

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

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

Генератор в примере выше будет генерировать 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)

# Output
> 0
> 1
> 4
> 9
> 16
> 25

Функция выше возвращает генератор, который возвращает квадраты чисел от 0 до 5. Результаты выводятся при помощи цикла for.