Как изучить Python в 2022 году — [Пошаговое руководство] 🔥

Содержание

Введение в Python
Как установить Python
Как запускать программы на Python
Python 2 против Python 3
Основы Python
Переменные в Python
Выражения и утверждения в Python
Комментарии
Отступы в Python
Типы данных в Python
Операторы в Python
Оператор присваивания в Python
Арифметические операторы в Python
Операторы сравнения в Python
Логические операторы в Python
Побитовые операторы в Python
isи inв Python
Тернарный оператор в Python
Строки в Python
Логические значения в Python
Числа в Python
Целые числа в Python
Числа с плавающей запятой в Python
Комплексные числа в Python
Арифметические операции над числами в Python
Встроенные функции в Python
Константы в Python
Перечисления в Python
Пользовательский ввод в Python
Управляющие операторы в Python
Списки на Python
Кортежи в Python
Словари на Python
Наборы в Python
Функции в Python
Объекты в Python
Циклы в Python
while циклы в Python
for циклы в Python
Прервать и продолжить в Python
Классы на Python
Модули в Python
Стандартная библиотека Python
Руководство по стилю PEP8 Python
Отладка в Python
Область видимости переменной в Python
Как принимать аргументы из командной строки в Python
Лямбда-функции в Python
Рекурсия в Python
Вложенные функции в Python
Замыкания в Python
Декораторы в Python
Строки документации в Python
Самоанализ в Python
Аннотации в Python
Исключения в Python
withЗаявление в Python
Как установить сторонние пакеты в Python с помощью pip
Составление списков в Python
Полиморфизм в Python
Перегрузка оператора в Python
Виртуальные среды в Python

Введение в Python

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

Python превосходен в большом количестве сценариев — сценарии оболочки , автоматизация задач и веб-разработка — это лишь некоторые основные примеры.

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

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

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

Благодаря этому уникальному положению Python, вероятно, будет расти еще больше в будущем.

Язык простой, выразительный и довольно понятный.

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

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

Его также ценят профессионалы в самых разных областях.

С технической точки зрения Python — это интерпретируемый язык, у которого нет промежуточной фазы компиляции, как у скомпилированного языка, например C или Java.

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

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

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

Начать с Python очень просто. Все, что вам нужно, это установить официальный пакет с python.org для Windows, macOS или Linux, и все готово.

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

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

Языки более низкого уровня, такие как C ++ и Rust, могут быть хорошими для опытных программистов, но они пугающие с самого начала, и на их освоение уходит много времени.

Python, с другой стороны, — это язык программирования для всех: студентов, людей, выполняющих свою повседневную работу с Excel, ученых и других.

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

Как установить Python

Перейдите на https://www.python.org , выберите меню Загрузки, выберите свою операционную систему, и появится панель со ссылкой для загрузки официального пакета:

Убедитесь, что вы следуете специальным инструкциям для вашей операционной системы. В macOS вы можете найти подробное руководство на https://flaviocopes.com/python-installation-macos/ .

Как запускать программы на Python

Есть несколько разных способов запуска программ Python.

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

Начнем с интерактивных подсказок.

Если вы откроете свой терминал и наберете python, вы увидите такой экран:

Это Python REPL (Read-Evaluate-Print-Loop).

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

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

name = "Flavio"

а затем распечатайте его значение, используя print():

print(name)

Примечание: в REPL вы также можете просто ввести name, нажать enterклавишу, и вы вернете значение. Но в программе вы не увидите никакого вывода, если вы это сделаете — вам нужно print()вместо этого использовать .

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

Введите, quit()чтобы выйти из этого Python REPL.

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

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

Это основы, которые поставляются с Python по умолчанию. Однако я рекомендую вам установить IPython , вероятно, лучшее приложение REPL для командной строки, которое вы можете найти.

Установите его с помощью

pip install ipython

Убедитесь, что двоичные файлы pip находятся на вашем пути, затем запустите ipython:

ipython — это еще один интерфейс, который позволяет вам работать с Python REPL и предоставляет некоторые полезные функции, такие как подсветка синтаксиса, автозавершение кода и многое другое.

Второй способ запустить программу Python — записать программный код Python в файл, например program.py:

а затем запустите его с помощью python program.py:

Обратите внимание, что мы сохраняем программы Python с .pyрасширением — это соглашение.

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

Мы используем REPL для быстрого создания прототипов и обучения.

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

В моей системе находится исполняемый файл Python /usr/bin/python3, поэтому я ввожу #!/usr/bin/python3первую строку:

Затем я могу установить разрешение на выполнение для файла:

chmod u+x program.py

и я могу запустить программу с

./program.py

Это особенно полезно при написании сценариев, взаимодействующих с терминалом.

У нас есть много других способов запускать программы Python.

Один из них использует VS Code и, в частности, официальное расширение Python от Microsoft:

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

Python: запустите REPL, чтобы запустить REPL во встроенном терминале:

Python: запустите файл Python в терминале, чтобы запустить текущий файл в терминале:

Python: запустить текущий файл в интерактивном окне Python :

и многое другое. Просто откройте палитру команд (Вид -> Палитра команд или Cmd-Shift-P) и введите, pythonчтобы увидеть все команды, связанные с Python:

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

Зарегистрируйтесь (это бесплатно), затем в разделе «Создать ответ» нажмите Python:

и вам сразу же будет показан редактор с main.pyфайлом, готовый к заполнению большим количеством кода Python:

Когда у вас есть код, нажмите «Выполнить», чтобы запустить его в правой части окна:

Я думаю, что репл. Это удобно, потому что:

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

Python 2 против Python 3

Одной из ключевых тем, которую мы должны рассмотреть с самого начала, является обсуждение Python 2 и Python 3.

Python 3 был представлен в 2008 году и находился в разработке как основная версия Python, в то время как Python 2 продолжал поддерживаться с исправлениями ошибок и патчами безопасности до начала 2020 года.

В тот день поддержка Python 2 была прекращена.

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

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

Основы Python

Переменные в Python

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

В этом примере мы назначаем nameметке строку со значением «Роджер» :

name = "Roger"

Вот пример с числом:

age = 8

Имя переменной может состоять из символов, цифр и _символа подчеркивания. Это не может начинаться с числа. Это все допустимые имена переменных:

name1
AGE
aGE
a11111
my_name
_name

Это недопустимые имена переменных:

123
test!
name%

Кроме этого, допустимо все, кроме ключевого слова Python . Есть некоторые ключевые слова , как for, if, while, importи многие другие.

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

Выражения и утверждения в Python

Мы можем выразить любой код, возвращающий значение. Например

1 + 1
"Roger"

С другой стороны, оператор — это операция над значением. Например, это 2 утверждения:

name = "Roger"
print(name)

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

name = "Roger"; print(name)

Отступы в Python

Отступы в Python имеют смысл.

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

name = "Flavio"
    print(name)

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

В этом случае, если вы попытаетесь запустить эту программу, вы получите IndentationError: unexpected indentошибку, потому что отступ имеет особое значение.

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

Типы данных в Python

Python имеет несколько встроенных типов.

Если вы создадите nameпеременную, присвоив ей значение «Roger», автоматически эта переменная теперь представляет тип данных String .

name = "Roger"

Вы можете проверить тип переменной, используя type()функцию, передав переменную в качестве аргумента, а затем сравнив результат с str:

name = "Roger"
type(name) == str #True

Или используя isinstance():

name = "Roger"
isinstance(name, str) #True

Обратите внимание: чтобы увидеть Trueзначение в Python вне REPL, вам нужно обернуть этот код внутрь print(), но для ясности я избегаю его использования.

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

Во-первых, у нас есть числа. Целые числа представлены с помощью intкласса. Числа с плавающей запятой (дроби) имеют тип float:

age = 1
type(age) == int #True

fraction = 0.1
type(fraction) == float #True

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

name = "Flavio"
age = 20

Python автоматически определяет тип по типу значения.

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

name = str("Flavio")
anotherName = str(name)

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

age = int("20")
print(age) #20

fraction = 0.1
intFraction = int(fraction)
print(intFraction) #0

Это называется кастингом . Конечно, это преобразование может не всегда работать в зависимости от переданного значения. Если вы напишете testвместо 20строки выше, вы получите сообщение ValueError: invalid literal for int() with base 10: 'test'об ошибке.

Это только основы типов. У нас в Python намного больше типов:

complex для комплексных чисел
bool для логических значений
list для списков
tuple для кортежей
range для диапазонов
dict для словарей
set для наборов

и больше!

Скоро мы изучим их все.

Операторы в Python

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

Мы можем разделить операторы по типу выполняемой ими операции:

оператор присваивания
арифметические операторы
операторы сравнения
логические операторы
побитовые операторы

плюс несколько интересных вроде isи in.

Оператор присваивания в Python

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

age = 8

Или присвоить значение переменной другой переменной:

age = 8
anotherVariable = age

Начиная с Python 3.8, := оператор моржа используется для присвоения значения переменной как части другой операции. Например, внутри ifили в условной части цикла. Подробнее об этом позже.

Арифметические операторы в Python

Python имеет ряд арифметических операторов: +, -, *, /(деление), %(остаток), **(возведение в степень) и //(пол деление):

1 + 1 #2
2 - 1 #1
2 * 2 #4
4 / 2 #2
4 % 3 #1
4 ** 2 #16
4 // 2 #2

Обратите внимание, что вам не нужен пробел между операндами, но он удобен для чтения.

- также работает как оператор унарного минуса:

print(-4) #-4

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

"Roger" + " is a good dog"
#Roger is a good dog

Мы можем комбинировать оператор присваивания с арифметическими операторами:

+=
-=
*=
/=
%=
..и так далее

Пример:

age = 8
age += 1
# age is now 9

Операторы сравнения в Python

Python определяет несколько операторов сравнения:

==
!=
>
<
>=
<=

Вы можете использовать эти операторы для получения логического значения ( Trueили False) в зависимости от результата:

a = 1
b = 2

a == b #False
a != b #True
a > b #False
a <= b #True

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

Python дает нам следующие логические операторы:

not
and
or

При работе с атрибутами Trueили Falseони работают как логические И, ИЛИ и НЕ и часто используются при оценке ifусловных выражений:

condition1 = True
condition2 = False

not condition1 #False
condition1 and condition2 #False
condition1 or condition2 #True

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

orиспользуется в выражении возвращает значение первого операнда , который не является falsy значение ( False, 0, '', []..). В противном случае возвращается последний операнд.

print(0 or 1) ## 1
print(False or 'hey') ## 'hey'
print('hi' or 'hey') ## 'hi'
print([] or False) ## 'False'
print(False or []) ## '[]'

Документы Python описывают его как if x is false, then y, else x.

andоценивает только второй аргумент, если первый верен. Таким образом , если первый аргумент falsy ( False, 0, '', []..), он возвращает этот аргумент. В противном случае он оценивает второй аргумент:

print(0 and 1) ## 0
print(1 and 0) ## 0
print(False and 'hey') ## False
print('hi' and 'hey') ## 'hey'
print([] and False ) ## []
print(False and [] ) ## False

Документы Python описывают его как if x is false, then x, else y.

Побитовые операторы в Python

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

& выполняет двоичное И
| выполняет двоичное ИЛИ
^ выполняет бинарную операцию XOR
~ выполняет бинарную операцию НЕ
<< сдвиг влево
>> сдвиг вправо

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

`is`и `in`в Python

isназывается тождественным оператором . Он используется для сравнения двух объектов и возвращает истину, если оба являются одним и тем же объектом. Подробнее об объектах позже.

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

Тернарный оператор в Python

Тернарный оператор в Python позволяет быстро определять условное выражение.

Допустим, у вас есть функция, которая сравнивает ageпеременную со 18значением и возвращает True или False в зависимости от результата.

Вместо того, чтобы писать:

def is_adult(age):
    if age > 18:
        return True
    else:
        return False

Вы можете реализовать это с помощью тернарного оператора следующим образом:

def is_adult(age):
    return True if age > 18 else False

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

<result_if_true> if <condition> else <result_if_false>

Строки в Python

Строка в Python — это последовательность символов, заключенных в кавычки или двойные кавычки:

"Roger"
'Roger'

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

name = "Roger"

Вы можете объединить две строки с помощью +оператора:

phrase = "Roger" + " is a good dog"

Вы можете добавить к строке, используя +=:

name = "Roger"
name += " is a good dog"

print(name) #Roger is a good dog

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

str(8) #"8"

Это необходимо для объединения числа в строку:

print("Roger is " + str(8) + " years old") #Roger is 8 years old

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

print("""Roger is

    8

years old
""")

#double quotes, or single quotes

print('''
Roger is

    8

years old
''')

Строка имеет набор встроенных методов, например:

isalpha() чтобы проверить, содержит ли строка только символы и не является ли она пустой
isalnum() чтобы проверить, содержит ли строка символы или цифры и не является ли она пустой
isdecimal() чтобы проверить, содержит ли строка цифры и не является ли она пустой
lower() чтобы получить строчную версию строки
islower() чтобы проверить, является ли строка строчной
upper() чтобы получить версию строки в верхнем регистре
isupper() чтобы проверить, является ли строка прописной
title() чтобы получить версию строки с заглавной буквы
startsswith() чтобы проверить, начинается ли строка с определенной подстроки
endswith() чтобы проверить, заканчивается ли строка определенной подстрокой
replace() заменить часть строки
split() чтобы разделить строку по определенному разделителю символов
strip() чтобы обрезать пробелы в строке
join() добавлять новые буквы в строку
find() найти позицию подстроки

и многое другое.

Ни один из этих методов не изменяет исходную строку. Вместо этого они возвращают новую измененную строку. Например:

name = "Roger"
print(name.lower()) #"roger"
print(name) #"Roger"

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

В частности, я думаю о том len(), что дает вам длину строки:

name = "Roger"
print(len(name)) #5

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

name = "Roger"
print("ger" in name) #True

Экранирование — это способ добавления специальных символов в строку.

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

name = "Roger"

"Ro"Ger"не будет работать, так как Python будет думать, что строка заканчивается на "Ro".

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

name = "Ro\"ger"

Это относится и к одинарным кавычкам \', и к специальным символам форматирования, таким как \tтабуляция, \nновая строка и \\обратная косая черта.

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

name = "Roger"
name[0] #'R'
name[1] #'o'
name[2] #'g'

Использование отрицательного числа приведет к отсчету с конца:

name = "Roger"
name[-1] #"r"

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

name = "Roger"
name[0:2] #"Ro"
name[:2] #"Ro"
name[2:] #"ger"

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

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

done = False
done = True

Логические значения особенно полезны с условными управляющими структурами, такими как ifоператоры:

done = True

if done:
    # run some code here
else:
    # run some other code

При оценке значения для Trueили False, если значение не a, boolу нас есть некоторые правила в зависимости от типа, который мы проверяем:

числа всегда Trueкроме числа0
строки Falseтолько когда пустые
списки, кортежи, наборы и словари Falseтолько тогда, когда они пусты

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

done = True
type(done) == bool #True

Или используя isinstance(), передав 2 аргумента: переменную и boolкласс:

done = True
isinstance(done, bool) #True

Глобальная any()функция также очень полезна при работе с логическими значениями, поскольку она возвращает, Trueесли любое из значений итерируемого объекта (например, списка), переданного в качестве аргумента, равно True:

book_1_read = True
book_2_read = False

read_any_book = any([book_1_read, book_2_read])

Глобальная all()функция такая же, но возвращается, Trueесли все переданные ей значения True:

ingredients_purchased = True
meal_cooked = False

ready_to_serve = all([ingredients_purchased, meal_cooked])

Числа в Python

Числа в Python могут быть 3 -х типов: int, floatи complex.

Целые числа в Python

Целые числа представлены с помощью intкласса. Вы можете определить целое число, используя литерал значения:

age = 8

Вы также можете определить целое число с помощью int()конструктора:

age = int(8)

Чтобы проверить, имеет ли переменная тип int, вы можете использовать type()глобальную функцию:

type(age) == int #True

Числа с плавающей запятой в Python

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

fraction = 0.1

Или с помощью float()конструктора:

fraction = float(0.1)

Чтобы проверить, имеет ли переменная тип float, вы можете использовать type()глобальную функцию:

type(fraction) == float #True

Комплексные числа в Python

Комплексные числа относятся к типу complex.

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

complexNumber = 2+3j

или используя complex()конструктор:

complexNumber = complex(2, 3)

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

complexNumber.real #2.0
complexNumber.imag #3.0

Опять же, чтобы проверить, имеет ли переменная тип complex, вы можете использовать type()глобальную функцию:

type(complexNumber) == complex #True

Арифметические операции над числами в Python

Можно выполнять арифметические операции над числами, используя арифметические операции: +, -, *, /(деление), %(остаток), **(возведение в степень) и //(пол деление):

1 + 1 #2
2 - 1 #1
2 * 2 #4
4 / 2 #2
4 % 3 #1
4 ** 2 #16
4 // 2 #2

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

+=
-=
*=
/=
%=
..и так далее

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

age = 8
age += 1

Встроенные функции в Python

Есть 2 встроенные функции, которые помогают с числами:

abs() возвращает абсолютное значение числа.

round() для заданного числа возвращает его значение, округленное до ближайшего целого числа:

round(0.12) #0

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

round(0.12, 1) #0.1

Некоторые другие математические служебные функции и константы предоставляются стандартной библиотекой Python:

mathпакет обеспечивает общее математические функции и константы
в cmathпакете есть утилиты для работы с комплексными числами.
в decimalпакете есть утилиты для работы с десятичными и плавающими числами.
в fractionsпакете есть утилиты для работы с рациональными числами.

Позже мы рассмотрим некоторые из них отдельно.

Константы в Python

Python не имеет возможности заставить переменную быть константой.

Ближайшее, что вы можете получить, — это использовать перечисление:

class Constants(Enum):
    WIDTH = 1024
    HEIGHT = 256

И переходите к каждому значению, используя, например Constants.WIDTH.value,.

Никто не может переназначить это значение.

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

WIDTH = 1024

Никто не помешает вам перезаписать это значение, и Python не остановит это.

Это то, что делает большая часть кода Python, что вы увидите.

Перечисления в Python

Перечисления — это читаемые имена, привязанные к постоянному значению.

Чтобы использовать перечисления, импортируйте Enumиз enumстандартного библиотечного модуля:

from enum import Enum

Затем вы можете инициализировать новое перечисление следующим образом:

class State(Enum):
    INACTIVE = 0
    ACTIVE = 1

Как только вы это сделаете, вы можете ссылаться на State.INACTIVEи State.ACTIVE, и они будут служить константами.

Теперь, если вы попытаетесь напечатать, State.ACTIVEнапример:

print(State.ACTIVE)

он не вернется 1, но State.ACTIVE.

Такое же значение может быть достигнуто по номеру, указанному в перечислении: print(State(1))вернется State.ACTIVE. То же самое для обозначения квадратных скобок State['ACTIVE'].

Однако вы можете получить значение, используя State.ACTIVE.value.

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

list(State) # [<State.INACTIVE: 0>, <State.ACTIVE: 1>]

Их можно посчитать:

len(State) # 2

Пользовательский ввод в Python

В приложении командной строки Python вы можете отображать информацию пользователю с помощью print()функции:

name = "Roger"
print(name)

Мы также можем принимать ввод от пользователя, используя input():

print('What is your age?')
age = input()
print('Your age is ' + age)

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

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

Это работает для приложений командной строки. Для других типов приложений потребуется другой способ приема вводимых данных.

Управляющие операторы в Python

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

В Python мы делаем это с помощью ifоператора:

condition = True

if condition == True:
    # do something

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

Что такое блок? Блок — это та часть, которая имеет отступ на один уровень (обычно 4 пробела) справа:

condition = True

if condition == True:
    print("The condition")
    print("was true")

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

condition = True

if condition == True:
    print("The condition")
    print("was true")

print("Outside of the if")

В сочетании с у ifвас может быть elseблок, который выполняется, если проверка условий ifприводит к False:

condition = True

if condition == True:
    print("The condition")
    print("was True")
else:
    print("The condition")
    print("was False")

И у вас могут быть разные связанные ifпроверки, elifкоторые выполняются, если предыдущая проверка была False:

condition = True
name = "Roger"

if condition == True:
    print("The condition")
    print("was True")
elif name == "Roger":
    print("Hello Roger")
else:
    print("The condition")
    print("was False")

Второй блок в этом случае выполняется, если conditionесть False, и nameзначение переменной — «Roger».

В ifзаявлении вы можете иметь только один ifи elseчек, но несколько серий elifпроверок:

condition = True
name = "Roger"

if condition == True:
    print("The condition")
    print("was True")
elif name == "Roger":
    print("Hello Roger")
elif name == "Syd":
    print("Hello Syd")
elif name == "Flavio":
    print("Hello Flavio")
else:
    print("The condition")
    print("was False")

ifи elseтакже может использоваться во встроенном формате, который позволяет нам возвращать то или иное значение в зависимости от условия.

Пример:

a = 2
result = 2 if a == 0 else 3
print(result) # 3

Списки на Python

Списки — это важная структура данных Python.

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

Например:

dogs = ["Roger", "Syd"]

Список может содержать значения разных типов:

items = ["Roger", 1, "Syd", True]

Вы можете проверить, содержится ли элемент в списке с помощью inоператора:

print("Roger" in items) # True

Список также можно определить как пустой:

items = []

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

items[0] # "Roger"
items[1] # 1
items[3] # True

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

items[0] = "Roger"

Вы также можете использовать index()метод:

items.index(0) # "Roger"
items.index(1) # 1

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

items[-1] # True

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

items[0:2] # ["Roger", 1]
items[2:] # ["Syd", True]

Получите количество элементов, содержащихся в списке, используя len()глобальную функцию, такую же, как мы использовали для получения длины строки:

len(items) #4

Вы можете добавлять элементы в список, используя append()метод списка :

items.append("Test")

или метод extend ():

items.extend(["Test"])

Вы также можете использовать +=оператор:

items += ["Test"]

# items is ['Roger', 1, 'Syd', True, 'Test']

Совет: используйте квадратные скобки extend()или +=не забудьте. Не делайте items += "Test"или items.extend("Test")или Python добавит в список 4 отдельных символа, в результате чего['Roger', 1, 'Syd', True, 'T', 'e', 's', 't']

Удалите элемент с помощью remove()метода:

items.remove("Test")

Вы можете добавить несколько элементов, используя

items += ["Test1", "Test2"]

#or

items.extend(["Test1", "Test2"])

Они добавляют элемент в конец списка.

Чтобы добавить элемент в середину списка по определенному индексу, используйте insert()метод:

items.insert("Test", 1) # add "Test" at index 1

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

items[1:1] = ["Test1", "Test2"]

Отсортируйте список с помощью sort()метода:

items.sort()

Совет: sort () будет работать только в том случае, если список содержит значения, которые можно сравнивать. Например, нельзя сравнивать строки и целые числа, и вы получите сообщение об ошибке, как TypeError: '<' not supported between instances of 'int' and 'str'если бы вы попытались.

Эти sort()методы заказы прописных букв, а затем строчные буквы. Чтобы исправить это, используйте:

items.sort(key=str.lower)

вместо.

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

itemscopy = items[:]

или используйте sorted()глобальную функцию:

print(sorted(items, key=str.lower))

который вернет новый отсортированный список вместо изменения исходного списка.

Кортежи в Python

Кортежи — еще одна фундаментальная структура данных Python.

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

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

names = ("Roger", "Syd")

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

names[0] # "Roger"
names[1] # "Syd"

Вы также можете использовать index()метод:

names.index('Roger') # 0
names.index('Syd')   # 1

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

names[-1] # True

Вы можете подсчитать элементы в кортеже с помощью len()функции:

len(names) # 2

Вы можете проверить, содержится ли элемент в кортеже, с помощью inоператора:

print("Roger" in names) # True

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

names[0:2] # ('Roger', 'Syd')
names[1:] # ('Syd',)

Получите количество элементов в кортеже, используя len()глобальную функцию, такую же, как мы использовали для получения длины строки:

len(names) #2

Вы можете создать отсортированную версию кортежа, используя sorted()глобальную функцию:

sorted(names)

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

newTuple = names + ("Vanille", "Tina")

Словари на Python

Словари — очень важная структура данных Python.

В то время как списки позволяют создавать коллекции значений, словари позволяют создавать коллекции пар ключ / значение .

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

dog = { 'name': 'Roger' }

Ключ может быть любым неизменяемым значением, например строкой, числом или кортежем. Значение может быть любым.

Словарь может содержать несколько пар ключ / значение:

dog = { 'name': 'Roger', 'age': 8 }

Вы можете получить доступ к отдельным ключевым значениям, используя эту нотацию:

dog['name'] # 'Roger'
dog['age']  # 8

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

dog['name'] = 'Syd'

И еще один способ — использовать get()метод, в котором есть возможность добавить значение по умолчанию:

dog.get('name') # 'Roger'
dog.get('test', 'default') # 'default'

pop()Метод возвращает значение ключа, а затем удаляет элемент из словаря:

dog.pop('name') # 'Roger'

В popitem()методе извлекает и удаляет последний ключ / значение пара вставляется в словарь:

dog.popitem()

Проверить, содержится ли ключ в словаре, можно с помощью inоператора:

'name' in dog # True

Получите список с ключами в словаре с помощью keys()метода, передав его результат list()конструктору:

list(dog.keys()) # ['name', 'age']

Получите значения с помощью values()метода и кортежи пар ключ / значение с помощью items()метода:

print(list(dog.values()))
# ['Roger', 8]

print(list(dog.items()))
# [('name', 'Roger'), ('age', 8)]

Получите длину словаря, используя len()глобальную функцию, такую же, как мы использовали для получения длины строки или элементов в списке:

len(dog) #2

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

dog['favorite food'] = 'Meat'

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

del dog['favorite food']

Чтобы скопировать словарь, используйте метод copy ():

dogCopy = dog.copy()

Наборы в Python

Наборы — еще одна важная структура данных Python.

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

Или мы можем сказать, что они работают как словари, но у них нет ключей.

У них также есть неизменная версия, называемая frozenset.

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

names = {"Roger", "Syd"}

Наборы работают хорошо, если вы думаете о них как о математических наборах.

Вы можете пересечь два множества:

set1 = {"Roger", "Syd"}
set2 = {"Roger"}

intersect = set1 & set2 #{'Roger'}

Вы можете создать объединение двух наборов:

set1 = {"Roger", "Syd"}
set2 = {"Luna"}

union = set1 | set2
#{'Syd', 'Luna', 'Roger'}

Вы можете получить разницу между двумя наборами:

set1 = {"Roger", "Syd"}
set2 = {"Roger"}

difference = set1 - set2 #{'Syd'}

Вы можете проверить, является ли набор надмножеством другого (и, конечно, если набор является подмножеством другого):

set1 = {"Roger", "Syd"}
set2 = {"Roger"}

isSuperset = set1 > set2 # True

Вы можете подсчитать количество предметов в наборе с помощью len()глобальной функции:

names = {"Roger", "Syd"}
len(names) # 2

Вы можете получить список из элементов набора, передав набор list()конструктору:

names = {"Roger", "Syd"}
list(names) #['Syd', 'Roger']

Проверить, входит ли предмет в набор, можно с помощью inоператора:

print("Roger" in names) # True

Функции в Python

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

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

Вот пример функции, helloкоторая выводит «Hello!»:

def hello():
    print('Hello!')

Это определение функции . Есть имя ( hello) и тело, набор инструкций, который следует за двоеточием. Он имеет отступ на один уровень справа.

Чтобы запустить эту функцию, мы должны ее вызвать. Это синтаксис для вызова функции:

hello()

Мы можем выполнить эту функцию один или несколько раз.

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

Функция может принимать один или несколько параметров:

def hello(name):
    print('Hello ' + name + '!')

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

hello('Roger')

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

Аргумент может иметь значение по умолчанию, которое применяется, если аргумент не указан:

def hello(name='my friend'):
    print('Hello ' + name + '!')

hello()
#Hello my friend!

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

def hello(name, age):
    print('Hello ' + name + ', you are ' + str(age) + ' years old!')

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

hello('Roger', 8)

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

def change(value):
    value = 2

val = 1
change(val)

print(val) #1

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

Функция может возвращать значение с помощью returnоператора. Например, в этом случае мы возвращаем nameимя параметра:

def hello(name):
    print('Hello ' + name + '!')
    return name

Когда функция встречает returnоператор, функция завершается.

Мы можем опустить значение:

def hello(name):
    print('Hello ' + name + '!')
    return

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

def hello(name):
    if not name:
        return
    print('Hello ' + name + '!')

Если мы вызываем функцию, передающую значение, которое оценивается Falseкак пустая строка, функция завершается до достижения print()оператора.

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

def hello(name):
    print('Hello ' + name + '!')
    return name, 'Roger', 8

В этом случае вызывающему hello('Syd')возвращаемое значение является кортеж , содержащий эти 3 значения: ('Syd', 'Roger', 8).

Объекты в Python

Все в Python — это объект.

Даже значения базовых примитивных типов (целые, строковые, с плавающей запятой …) являются объектами. Списки — это объекты, как и кортежи, словари и все такое.

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

Например, попробуйте определить новую переменную типа int:

age = 8

ageтеперь имеет доступ к свойствам и методам, определенным для всех intобъектов.

Это включает, например, доступ к действительной и мнимой части этого числа:

print(age.real) # 8
print(age.imag) # 0

print(age.bit_length()) #4

# the bit_length() method returns the number of bits necessary to represent this number in binary notation

Переменная, содержащая значение списка, имеет доступ к другому набору методов:

items = [1, 2]
items.append(3)
items.pop()

Методы зависят от типа значения.

id()Глобальная функция , обеспечиваемая Python позволяет просматривать местоположение в памяти для конкретного объекта.

id(age) # 140170065725376

Ваше значение памяти изменится — я показываю это только в качестве примера.

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

age = 8

print(id(age)) # 140535918671808

age = 9

print(id(age)) # 140535918671840

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

items = [1, 2]

print(id(items)) # 140093713593920

items.append(3)

print(items) # [1, 2, 3]
print(id(items)) # 140093713593920

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

Некоторые объекты изменяемы , а другие неизменны . Это зависит от самого объекта.

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

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

age = 8
age = age + 1

#or

age += 1

и вы проверите id(age), вы обнаружите, что это ageуказывает на другое место в памяти. Исходное значение не изменилось, мы просто перешли на другое значение.

Циклы в Python

Циклы — одна из важнейших частей программирования.

В Python мы имеем 2 вида петель: в то время как петли и для петель .

`while` циклы в Python

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

condition = True
while condition == True:
    print("The condition is True")

Это бесконечный цикл . Это никогда не кончится.

Остановим цикл сразу после первой итерации:

condition = True
while condition == True:
    print("The condition is True")
    condition = False

print("After the loop")

В этом случае выполняется первая итерация, в соответствии с которой оценивается проверка условия True. На второй итерации выполняется проверка условия False, поэтому управление переходит к следующей инструкции после цикла.

Обычно есть счетчик для остановки итерации после некоторого количества циклов:

count = 0
while count < 10:
    print("The condition is True")
    count = count + 1

print("After the loop")

`for` циклы в Python

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

Например, мы можем перебирать элементы в списке:

items = [1, 2, 3, 4]
for item in items:
    print(item)

Или вы можете выполнить итерацию определенное количество раз, используя range()функцию:

for item in range(04):
    print(item)

range(4)создает последовательность , которая начинается от 0 и содержит 4 элемента: [0, 1, 2, 3].

Чтобы получить индекс, вы должны заключить последовательность в enumerate()функцию:

items = [1, 2, 3, 4]
for index, item in enumerate(items):
    print(index, item)

Прервать и продолжить в Python

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

continue останавливает текущую итерацию и сообщает Python выполнить следующую.

break полностью останавливает цикл и продолжает выполнение следующей инструкции после завершения цикла.

Первый пример здесь печатает 1, 3, 4. Второй пример печатает 1:

items = [1, 2, 3, 4]
for item in items:
    if item == 2:
        continue
    print(item)

items = [1, 2, 3, 4]
for item in items:
    if item == 2:
        break
    print(item)

Классы на Python

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

Объект — это экземпляр класса. Класс — это тип объекта.

Мы можем определить класс таким образом:

class <class_name>:
    # my class

Например, давайте определим класс Dog

class Dog:
    # the Dog class

Класс может определять методы:

class Dog:
    # the Dog class
    def bark(self):
        print('WOF!')

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

Мы создаем экземпляр класса, объект , используя этот синтаксис:

roger = Dog()

Теперь rogerэто новый объект типа Dog.

Если ты бежишь

print(type(roger))

Ты получишь <class '__main__.Dog'>

Особый тип метода __init__()называется конструктором, и мы можем использовать его для инициализации одного или нескольких свойств при создании нового объекта из этого класса:

class Dog:
    # the Dog class
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print('WOF!')

Мы используем это так:

roger = Dog('Roger', 8)
print(roger.name) # 'Roger'
print(roger.age)  # 8

roger.bark() # 'WOF!'

Важная особенность классов — наследование.

Мы можем создать класс Animal с помощью метода walk():

class Animal:
    def walk(self):
        print('Walking..')

а класс Dog может быть унаследован от Animal:

class Dog(Animal):
    def bark(self):
        print('WOF!')

Теперь создание нового объекта класса Dogбудет иметь walk()метод, унаследованный от Animal:

roger = Dog()
roger.walk() # 'Walking..'
roger.bark() # 'WOF!'

Модули в Python

Каждый файл Python — это модуль.

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

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

Файл dog.pyсодержит этот код:

def bark():
    print('WOF!')

Мы можем импортировать эту функцию из другого файла, используя import. И как только мы это сделаем, мы можем ссылаться на функцию, используя точечную нотацию dog.bark():

import dog

dog.bark()

Или мы можем использовать from .. importсинтаксис и напрямую вызвать функцию:

from dog import bark

bark()

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

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

Эти модули специфичны для вашей программы, и импорт зависит от местоположения файла в файловой системе.

Предположим, вы поместили dog.pyв libподпапку.

В этой папке вам нужно создать пустой файл с именем __init__.py. Это сообщает Python, что папка содержит модули.

Теперь вы можете выбрать — вы можете импортировать dogиз lib:

from lib import dog

dog.bark()

или вы можете ссылаться на dogконкретную функцию модуля, импортируемую из lib.dog:

from lib.dog import bark

bark()

Стандартная библиотека Python

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

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

Вы можете найти полный список стандартных библиотечных модулей здесь: https://docs.python.org/3/library/index.html

Некоторые из важных модулей:

math для математических утилит
re для регулярных выражений
json работать с JSON
datetime работать с датами
sqlite3 использовать SQLite
os для утилит операционной системы
random для генерации случайных чисел
statistics для утилит статистики
requests для выполнения сетевых HTTP-запросов
http для создания HTTP-серверов
urllib управлять URL-адресами

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

То же самое и с модулями стандартной библиотеки:

import math

math.sqrt(4) # 2.0

или же

from math import sqrt

sqrt(4) # 2.0

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

Руководство по стилю PEP8 Python

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

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

Python определяет свои соглашения в руководстве по стилю PEP8. PEP расшифровывается как Python Enhancement Proposals, и это место, где происходят все улучшения и обсуждения языка Python.

Есть много предложений PEP, все они доступны по адресу https://www.python.org/dev/peps/ .

PEP8 — один из первых, а также один из самых важных. Он определяет форматирование, а также некоторые правила написания Python «питоническим» способом.

Вы можете прочитать его полное содержание здесь: https://www.python.org/dev/peps/pep-0008/, но вот краткое изложение важных моментов, с которых вы можете начать:

Отступ с использованием пробелов, а не табуляции
Сделайте отступ в 4 пробела.
Файлы Python кодируются в UTF-8
Используйте максимум 80 столбцов для вашего кода
Напишите каждое утверждение в отдельной строке
Функции, имена переменных и имена файлов пишутся строчными буквами с подчеркиванием между словами (snake_case)
Имена классов пишутся с заглавной буквы, отдельные слова тоже пишутся с заглавной буквы (CamelCase)
Имена пакетов в нижнем регистре и без подчеркивания между словами.
Переменные, которые не должны изменяться (константы), пишутся в верхнем регистре.
Имена переменных должны быть значимыми
Добавляйте полезные комментарии, но избегайте явных.
Добавьте пробелы вокруг операторов
Не используйте ненужные пробелы
Добавить пустую строку перед функцией
Добавьте пустую строку между методами в классе
Внутри функций / методов пустые строки могут использоваться для разделения связанных блоков кода для облегчения чтения.

Отладка в Python

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

У каждого языка есть свой отладчик. У Python есть pdb, доступный через стандартную библиотеку.

Вы отлаживаете, добавляя одну точку останова в свой код:

breakpoint()

При необходимости вы можете добавить больше точек останова.

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

Тогда и вы сможете сделать несколько вещей.

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

Вы можете нажать, nчтобы перейти к следующей строке в текущей функции. Если код вызывает функции, отладчик в них не лезет, а считает их «черными ящиками».

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

Вы можете нажать, cчтобы продолжить выполнение программы в обычном режиме, без необходимости делать это шаг за шагом.

Вы можете нажать, qчтобы остановить выполнение программы.

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

Область видимости переменной в Python

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

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

age = 8

def test():
    print(age)

print(age) # 8
test() # 8

Мы называем это глобальной переменной .

Если вы определяете переменную внутри функции, эта переменная является локальной переменной и видна только внутри этой функции. Вне функции он недоступен:

def test():
    age = 8
    print(age)

test() # 8

print(age)
# NameError: name 'age' is not defined

Как принимать аргументы из командной строки в Python

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

До сих пор вы запускали программы либо из REPL, либо с помощью

python <filename>.py

При этом вы можете передать дополнительные аргументы и параметры, например:

python <filename>.py <argument1>
python <filename>.py <argument1> <argument2>

Базовый способ обработки этих аргументов — использовать sysмодуль из стандартной библиотеки.

Вы можете получить аргументы, переданные в sys.argvсписке:

import sys
print(len(sys.argv))
print(sys.argv)

sys.argvСписок содержит в качестве первого элемента имени файла , который был запущен, например ['main.py'].

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

Python предоставляет еще один пакет в стандартной библиотеке , чтобы помочь вам: argparse.

Сначала вы импортируете argparseи вызываете argparse.ArgumentParser(), передавая описание вашей программы:

import argparse

parser = argparse.ArgumentParser(
    description='This program prints the name of my dogs'
)

Затем вы переходите к добавлению аргументов, которые хотите принять.
Например, в этой программе мы принимаем -cопцию передачи цвета, например:python program.py -c red

import argparse

parser = argparse.ArgumentParser(
    description='This program prints a color HEX value'
)

parser.add_argument('-c', '--color', metavar='color', required=True, help='the color to search for')

args = parser.parse_args()

print(args.color) # 'red'

Если аргумент не указан, программа выдает ошибку:

➜  python python program.py
usage: program.py [-h] -c color
program.py: error: the following arguments are required: -c

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

parser.add_argument('-c', '--color', metavar='color', required=True, choices={'red','yellow'}, help='the color to search for')

➜  python python program.py -c blue
usage: program.py [-h] -c color
program.py: error: argument -c/--color: invalid choice: 'blue' (choose from 'yellow', 'red')

Есть еще варианты, но это основы.

И есть пакеты сообщества, которые также предоставляют эту функцию, например Click и Python Prompt Toolkit .

Лямбда-функции в Python

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

В Python они определяются с помощью lambdaключевого слова:

lambda <arguments> : <expression>

Тело должно быть единственным выражением — выражением, а не утверждением.

Эта разница важна. Выражение возвращает значение, а инструкция — нет.

Простейшим примером лямбда-функции является функция, удваивающая значение числа:

lambda num : num * 2

Лямбда-функции могут принимать больше аргументов:

lambda a, b : a * b

Лямбда-функции нельзя вызывать напрямую, но вы можете назначать их переменным:

multiply = lambda a, b : a * b

print(multiply(2, 2)) # 4

Полезность лямбда-функций появляется в сочетании с другими функциями Python, например, в сочетании с map(), filter()и reduce().

Рекурсия в Python

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

Обычный способ объяснить рекурсию — использовать факториальное вычисление.

Факториал числа — это число, nумноженное на n-1, умноженное на n-2… и так далее, пока не будет достигнуто число 1:

3! = 3 * 2 * 1 = 6
4! = 4 * 3 * 2 * 1 = 24
5! = 5 * 4 * 3 * 2 * 1 = 120

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

def factorial(n):
    if n == 1: return 1
    return n * factorial(n-1)

print(factorial(3)) #   6
print(factorial(4)) #  24
print(factorial(5)) # 120

Если внутри factorial()вызываемой функции factorial(n)вместо factorial(n-1), вы вызовете бесконечную рекурсию. Python по умолчанию останавливает рекурсию при 1000 вызовах, и при достижении этого лимита вы получите сообщение RecursionErrorоб ошибке.

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

Вложенные функции в Python

Функции в Python могут быть вложены в другие функции.

Функция, определенная внутри функции, видна только внутри этой функции.

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

Вы спросите: а зачем мне «прятать» эту функцию, если она не вредит?

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

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

Вот пример:

def talk(phrase):
    def say(word):
        print(word)

    words = phrase.split(' ')
    for word in words:
        say(word)

talk('I am going to buy the milk')

Если вы хотите получить доступ к переменной, определенной во внешней функции, из внутренней функции, вам сначала нужно объявить ее как nonlocal:

def count():
    count = 0

    def increment():
        nonlocal count
        count = count + 1
        print(count)

    increment()

count()

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

Замыкания в Python

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

Вот простой встречный пример.

def counter():
    count = 0

    def increment():
        nonlocal count
        count = count + 1
        return count

    return increment

increment = counter()

print(increment()) # 1
print(increment()) # 2
print(increment()) # 3

Мы возвращаем increment()внутреннюю функцию, и она по-прежнему имеет доступ к состоянию countпеременной, даже если counter()функция завершилась.

Декораторы в Python

Декораторы — это способ изменить, улучшить или каким-либо образом изменить работу функции.

Декораторы определяются с помощью @символа, за которым следует имя декоратора, непосредственно перед определением функции.

Пример:

@logtime
def hello():
    print('hello!')

Этой helloфункции logtimeназначен декоратор.

Каждый раз, когда мы вызываем hello(), будет вызван декоратор.

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

def logtime(func):
    def wrapper():
        # do something before
        val = func()
        # do something after
        return val
    return wrapper

Строки документации в Python

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

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

Комментарии — это один из способов помочь себе (и другим):

# this is a comment

num = 1 #this is another comment

Другой способ — использовать строки документации .

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

Вот как вы определяете строку документации для функции:

def increment(n):
    """Increment a number"""
    return n + 1

Вот как вы определяете строку документации для класса и метода:

class Dog:
    """A class representing a dog"""
    def __init__(self, name, age):
        """Initialize a new dog"""
        self.name = name
        self.age = age

    def bark(self):
        """Let the dog bark"""
        print('WOF!')

Задокументируйте модуль, разместив строку документации вверху файла, например, предположим, что это dog.py:

"""Dog module

This module does ... bla bla bla and provides the following classes:

- Dog
...
"""

class Dog:
    """A class representing a dog"""
    def __init__(self, name, age):
        """Initialize a new dog"""
        self.name = name
        self.age = age

    def bark(self):
        """Let the dog bark"""
        print('WOF!')

Строки документов могут занимать несколько строк:

def increment(n):
    """Increment
    a number
    """
    return n + 1

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

Например, вызов help(increment)даст вам следующее:

Help on function increment in module
__main__:

increment(n)
    Increment
    a number

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

Мне нравится стандарт Google: https://github.com/google/styleguide/blob/gh-pages/pyguide.md#38-comments-and-docstrings

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

Самоанализ в Python

Функции, переменные и объекты можно анализировать с помощью интроспекции .

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

Затем вы можете использовать print () для получения информации о функции:

def increment(n):
    return n + 1

print(increment)

# <function increment at 0x7f420e2973a0>

или объект:

class Dog():
    def bark(self):
        print('WOF!')

roger = Dog()

print(roger)

# <__main__.Dog object at 0x7f42099d3340>

type()Функция дает нам тип объекта:

print(type(increment))
# <class 'function'>

print(type(roger))
# <class '__main__.Dog'>

print(type(1))
# <class 'int'>

print(type('test'))
# <class 'str'>

dir()Глобальная функция позволяет нам узнать все методы и атрибуты объекта:

print(dir(roger))

# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bark']

В id()глобальной функции показывает нам место в памяти любого объекта:

print(id(roger)) # 140227518093024
print(id(1))     # 140227521172384

Может быть полезно проверить, указывают ли две переменные на один и тот же объект.

inspectСтандартный библиотечный модуль дает нам больше инструментов , чтобы получить информацию об объектах, и вы можете проверить его здесь: https://docs.python.org/3/library/inspect.html

Аннотации в Python

Python имеет динамическую типизацию. Нам не нужно указывать тип переменной или параметра функции или возвращаемое значение функции.

Аннотации позволяют нам (по желанию) сделать это.

Это функция без аннотаций:

def increment(n):
    return n + 1

Это та же функция с аннотациями:

def increment(n: int) -> int:
    return n + 1

Вы также можете аннотировать переменные:

count: int = 0

Python игнорирует эти аннотации. Отдельный инструмент под названием mypyможет быть запущен автономно или интегрирован в IDE, например VS Code или PyCharm, для автоматической статической проверки ошибок типа во время кодирования. Это также поможет вам обнаружить ошибки несоответствия типов еще до запуска кода.

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

Исключения в Python

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

Если вы поместите строки кода в try:блок:

try:
    # some lines of code

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

try:
    # some lines of code
except <ERROR1>:
    # handler <ERROR1>
except <ERROR2>:
    # handler <ERROR2>

Чтобы перехватить все исключения, вы можете использовать exceptбез какого-либо типа ошибки:

try:
    # some lines of code
except <ERROR1>:
    # handler <ERROR1>
except:
    # catch all other exceptions

elseБлок выполняется , если не было обнаружено никаких исключений:

try:
    # some lines of code
except <ERROR1>:
    # handler <ERROR1>
except <ERROR2>:
    # handler <ERROR2>
else:
    # no exceptions were raised, the code ran successfully

finallyБлок позволяет выполнять некоторые операции в любом случае, независимо от того, произошла ли ошибка или нет:

try:
    # some lines of code
except <ERROR1>:
    # handler <ERROR1>
except <ERROR2>:
    # handler <ERROR2>
else:
    # no exceptions were raised, the code ran successfully
finally:
    # do something in any case

Конкретная ошибка, которая может произойти, зависит от выполняемой вами операции.

Например, если вы читаете файл, вы можете получить расширение EOFError. Если вы разделите число на ноль, вы получите ZeroDivisionError. Если у вас есть проблема с преобразованием типов, вы можете получить файл TypeError.

Попробуйте этот код:

result = 2 / 0
print(result)

Программа завершится с ошибкой:

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    result = 2 / 0
ZeroDivisionError: division by zero

и строки кода после ошибки выполняться не будут.

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

try:
    result = 2 / 0
except ZeroDivisionError:
    print('Cannot divide by zero!')
finally:
    result = 1

print(result) # 1

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

raise Exception('An error occurred!')

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

try:
    raise Exception('An error occurred!')
except Exception as error:
    print(error)

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

class DogNotFoundException(Exception):
    pass

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

try:
    raise DogNotFoundException()
except DogNotFoundException:
    print('Dog not found!')

`with`Заявление в Python

Этот withоператор очень полезен для упрощения работы с обработкой исключений.

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

with делает этот процесс прозрачным.

Вместо того, чтобы писать:

filename = '/Users/flavio/test.txt'

try:
    file = open(filename, 'r')
    content = file.read()
    print(content)
finally:
    file.close()

Ты можешь написать:

filename = '/Users/flavio/test.txt'

with open(filename, 'r') as file:
    content = file.read()
    print(content)

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

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

Как установить сторонние пакеты в Python с помощью `pip`

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

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

Все эти модули собраны в одном месте, индекс пакетов Python доступен на https://pypi.org , и их можно установить в вашей системе с помощью pip.

На момент написания в свободном доступе более 270 000 пакетов.

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

Установите любой пакет с помощью команды pip install:

pip install <package>

или, если у вас есть проблемы, вы также можете запустить его python -m:

python -m pip install <package>

Например, вы можете установить requestsпакет популярной библиотеки HTTP:

pip install requests

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

Точное расположение зависит от вашей операционной системы.

На MacOS, работает на Python 3.9, расположение /Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages.

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

pip install –U <package>

Установите определенную версию пакета, используя:

pip install <package>==<version>

Удалите пакет, используя:

pip uninstall <package>

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

pip show <package>

Составление списков в Python

Составление списков — это очень лаконичный способ создания списков.

Предположим, у вас есть список:

numbers = [1, 2, 3, 4, 5]

Вы можете создать новый список, используя понимание списка, состоящее из numbersэлементов списка, степень 2:

numbers_power_2 = [n**2 for n in numbers]
# [1, 4, 9, 16, 25]

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

numbers_power_2 = []
for n in numbers:
    numbers_power_2.append(n**2)

и более map():

numbers_power_2 = list(map(lambda n : n**2, numbers))

Полиморфизм в Python

Полиморфизм обобщает функциональность, поэтому он может работать с разными типами. Это важная концепция объектно-ориентированного программирования.

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

class Dog:
    def eat():
        print('Eating dog food')

class Cat:
    def eat():
        print('Eating cat food')

Затем мы можем генерировать объекты и вызывать eat()метод независимо от класса, к которому принадлежит объект, и мы получим разные результаты:

animal1 = Dog()
animal2 = Cat()

animal1.eat()
animal2.eat()

Мы создали обобщенный интерфейс, и теперь нам не нужно знать, что животное — это кошка или собака.

Перегрузка оператора в Python

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

Возьмем класс Dog:

class Dog:
    # the Dog class
    def __init__(self, name, age):
        self.name = name
        self.age = age

Создадим 2 объекта Dog:

roger = Dog('Roger', 8)
syd = Dog('Syd', 7)

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

class Dog:
    # the Dog class
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __gt__(self, other):
        return True if self.age > other.age else False

Теперь, если вы попробуете бежать, print(roger > syd)вы получите результат True.

Таким же образом, как мы определили __gt__()(что означает больше чем), мы можем определить следующие методы:

__eq__() проверить на равенство
__lt__()чтобы проверить, следует ли считать один объект ниже другого, с помощью <оператора
__le__()для меньшего или равного ( <=)
__ge__()для большего или равного ( >=)
__ne__()для не равно ( !=)

Тогда у вас есть методы для взаимодействия с арифметическими операциями:

__add__()ответить +оператору
__sub__()ответить –оператору
__mul__()ответить *оператору
__truediv__()ответить /оператору
__floordiv__()ответить //оператору
__mod__()ответить %оператору
__pow__()ответить **оператору
__rshift__()ответить >>оператору
__lshift__()ответить <<оператору
__and__()ответить &оператору
__or__()ответить |оператору
__xor__()ответить ^оператору

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

Виртуальные среды в Python

Обычно в вашей системе работает несколько приложений Python.

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

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

Мы будем использовать venv. Остальные инструменты работают аналогично, вроде pipenv.

Создайте виртуальную среду, используя

python -m venv .venv

в папке, в которой вы хотите запустить проект или где у вас уже есть существующий проект.

Тогда беги

source .venv/bin/activate

Используйте source .venv/bin/activate.fishна рыбной раковине

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

Моя изменилась с

➜ folder

(.venv) ➜ folder

Теперь при запуске pipбудет использоваться эта виртуальная среда вместо глобальной.

Как изучить Python в 2022 — [Пошаговое руководство] 🔥

Введение в Python

Как установить Python

Как запускать программы на Python

Python 2 против Python 3

Основы Python

Переменные в Python

Выражения и утверждения в Python

Комментарии

Отступы в Python

Типы данных в Python

Операторы в Python

Оператор присваивания в Python

Арифметические операторы в Python

Операторы сравнения в Python

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

Побитовые операторы в Python

isи inв Python

Тернарный оператор в Python

Строки в Python

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

Числа в Python

Целые числа в Python

Числа с плавающей запятой в Python

Комплексные числа в Python

Арифметические операции над числами в Python

Встроенные функции в Python

Константы в Python

Перечисления в Python

Пользовательский ввод в Python

Управляющие операторы в Python

Списки на Python

Кортежи в Python

Словари на Python

Наборы в Python

Функции в Python

Объекты в Python

Циклы в Python

while циклы в Python

for циклы в Python

Прервать и продолжить в Python

Классы на Python

Модули в Python

Стандартная библиотека Python

Руководство по стилю PEP8 Python

Отладка в Python

Область видимости переменной в Python

Как принимать аргументы из командной строки в Python

Лямбда-функции в Python

Рекурсия в Python

Вложенные функции в Python

Замыкания в Python

Декораторы в Python

Строки документации в Python

Самоанализ в Python

Аннотации в Python

Исключения в Python

withЗаявление в Python

Как установить сторонние пакеты в Python с помощью pip

Составление списков в Python

Полиморфизм в Python

Перегрузка оператора в Python

Виртуальные среды в Python

`is`и `in`в Python

`while` циклы в Python

`for` циклы в Python

`with`Заявление в Python

Как установить сторонние пакеты в Python с помощью `pip`