Справочник Python

Автор оригинала: Flavio Copes.

Справочник Python следует за правилом 80/20: учиться 80% темы в 20% времени.

Я нахожу, что этот подход дает хорошо округлый обзор.

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

Я надеюсь, что содержимое этой книги поможет вам достичь того, что вы хотите: Узнайте основы Python Отказ

Примечание: вы можете Получите PDF, EPUB и MOBI версию этого справочника Python

Наслаждаться!

Резюме

• Введение в Питон
• Как установить Python
• Как запустить программы Python
• Python 2 против Python 3
• Основы Python
• Типы данных в Python
• Операторы в Питоне
• Тернарный оператор в Python
• Строки в Питоне
• Логин в Питоне
• Числа в Python
• Константы в Питоне
• Перечень в Питоне
• Пользователь ввод в Python
• Управление операторами в Python
• Списки в Python
• Кортежи в Питоне
• Словари в Python
• Наборы в Python
• Функции в Python
• Объекты в Питоне
• Петли в Питоне
• Классы в Python
• Модули в Python
• Стандартная библиотека Python
• Руководство по стилю Pep8 Python
• Отладка в Python
• Переменная область в Python
• Как принять аргументы из командной строки в Python
• Лямбда функции в Python
• Рекурсия в Питоне
• Вложенные функции в Python
• Закрытие в Питоне
• Декораторы в Питоне
• Docstrings в Python
• Анноспекция в Питоне
• Аннотации в Питоне
• Исключения в Python
• С заявлением в Python
• Как установить 3-я пакеты вечеринки в Python, используя PIP
• Список состоится в Python
• Полиморфизм в Питоне
• Оператор перегрузки в Python
• Виртуальные среды в Python
• Заключение

Введение в Питон

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

Python Excels в самых разных сценариях – Скрипты оболочки , Автоматизация задач и Веб-разработка просто некоторые основные примеры.

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

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

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

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

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

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

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

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

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

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

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

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

Создан в 1991 году Гвидо Ван Россомом, он поднимался популярностью – особенно за последние 5 лет, поскольку эта Google Trends Infographics показывает:

Начиная с 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-SELECTION-PRINT-LOOP).

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

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

name = "Flavio"

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

print(name)

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

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

Тип Quit () Чтобы выйти из этого Python REPL.

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

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

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

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

pip install ipython

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

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

Второй способ запуска программы 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-код, а в частности официальный расширение Python от Microsoft:

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

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

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

Python: запустить текущий файл в Python Interactive Window :

И многое другое. Просто откройте командную палитру (просмотр -> палитра команд, или CMD-Shift-p) и введите Python Чтобы увидеть все команды, связанные с Python:

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

Регистрация (это бесплатно), затем в разделе «Создать refr» Нажмите Python:

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

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

Я думаю, что reft.it удобно, потому что:

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

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

Основы Python

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

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

В этом примере мы назначаем строку со значением «Roger» на Имя метка:

name = "Roger"

Вот пример с номером:

age = 8

Имя переменной может быть состоит из символов, чисел и _ подчеркивающий характер. Это не может начать с номера. Это все Действительно Переменные имена:

name1
AGE
aGE
a11111
my_name
_name

Это Неверный Переменные имена:

123
test!
name%

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

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

Выражения и заявления в Python

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

1 + 1
"Roger"

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

name = "Roger"
print(name)

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

name = "Roger"; print(name)

Комментарии

В программе Python все после того, как хеш-след игнорируется, и считается комментарием:

#this is a commented line

name = "Roger" # this is an inline comment

Отступ в Python

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

Вы не можете сделать случайно, как это:

name = "Flavio"
    print(name)

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

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

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

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

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

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

name = "Roger"

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

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

Или использовать Isinstance () :

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

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

Мы использовали ул ...| Класс здесь, но те же произведения для других типов данных.

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

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

Это называется кастинг Отказ Конечно, это преобразование может не всегда работать в зависимости от передаваемого значения. Если вы пишете Тест вместо 20 В приведенной выше строке вы получите ValuctionError: неверный буквальный для INT () с базой 10: «Тест» ошибка.

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

• комплекс для сложных чисел
• Bool для логических
• Список для списков
• кортеж для кортежей
• Диапазон для диапазонов
• Диктовать для словарей
• Установить для наборов

и больше!

Мы рассмотрим их все в ближайшее время.

Операторы в Питоне

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

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

• Оператор назначения
• Арифметические операторы
• Операторы сравнения
• Логические операторы
• побитовые операторы

Плюс некоторые интересные, такие как это и в Отказ

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

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

age = 8

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

age = 8
anotherVariable = age

С момента Python 3.8, : = Оператор Walrus используется для назначения значения переменной как часть другой операции. Например, внутри Если или в условной части петли. Больше на этом позже.

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

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

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

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

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

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 дает нам следующие логические операторы:

• нет
• а также
• или же

При работе с Правда или Ложь Атрибуты, те работают как логические и, или, а не, и часто используются в Если Оценка условного выражения:

condition1 = True
condition2 = False

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

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

или Используется в выражении, возвращает значение первого операнда, который не является фальсионным значением ( 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 Docs описывает это как Если х неверно, то y, еще х Отказ

и только оценивает второй аргумент, если первый верно. Так что, если первый аргумент является фальсию ( 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 Docs описывает это как Если x ложный, то x, else y Отказ

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

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

• & Выполняет двоичное и
• |. Выполняет двоичный или
• ^ выполняет бинарную операцию XOR
• ~ выполняет двоичный не работает
• << Сдвиг левой работы
• >> Переместить правильную работу

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

есть и в Python

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

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

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

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

Допустим, у вас есть функция, которая сравнивает возраст Переменная к 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

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

 if  else 

Строки в Питоне

Строка в 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(8) #"8"

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

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

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

print("""Roger is

    8

years old
""")

#double quotes, or single quotes

print('''
Roger is

    8

years old
''')

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

• Isalpha () Чтобы проверить, содержит ли строка только символы и не пуста
• Isalnum () Чтобы проверить, содержит ли строка символов или цифр и не пуста
• isdecimal () Чтобы проверить, содержит ли строка цифр и не пуста
• ниже () Чтобы получить строчную версию строки
• islower () Чтобы проверить, строчная строка
• Верхний () Чтобы получить прописную версию строки
• Isupper () Чтобы проверить, является ли строка в верхнем регистре
• Название () Чтобы получить заглавную версию строки
• StartsSwith () Чтобы проверить, начинается ли строка с определенной подстроки
• Эндонсвит () Чтобы проверить, заканчивается ли строка определенной подстрокой
• заменить () заменить часть строки
• Сплит () Чтобы разделить строку на определенном сепараторе символов
• полоса () Обрезать пробел из строки
• Присоединяйтесь () добавить новые буквы в строку
• Найти () Чтобы найти положение подстроки

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

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

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

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

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

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

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

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 предоставляет Bool Тип, который может иметь два значения: Правда и Ложь (заглавные).

done = False
done = True

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

done = True

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

При оценке стоимости для Правда или Ложь , если значение не является Bool У нас есть несколько правил в зависимости от типа, который мы проверяем:

• Числа всегда Правда За исключением количества 0.
• Строки – это Ложь только когда пусто
• Списки, кортежи, наборы и словари – Ложь только когда пусто

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

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

Или использовать Isinstance () , прохождение 2 аргументов: переменная, и Bool класс:

done = True
isinstance(done, bool) #True

Глобальный любой () Функция также очень полезна при работе с логическими, как это возвращает Правда Если какое-либо из значений итерабельного (списка, например) прошло как аргумент, являются Правда :

book_1_read = True
book_2_read = False

read_any_book = any([book_1_read, book_2_read])

Глобальный все () Функция та же, но возвращает Правда Если все значения передаются на это Правда :

ingredients_purchased = True
meal_cooked = False

ready_to_serve = all([ingredients_purchased, meal_cooked])

Числа в Python

Числа в Python могут быть 3 видов: int , плавать и комплекс Отказ

Целочисленные номера в Python

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

age = 8

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

age = int(8)

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

type(age) == int #True

Числа плавающих точек в Python

Числа плавающих точек (фракции) имеют тип плавать Отказ Вы можете определить целое число, используя значение Littleal:

fraction = 0.1

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

fraction = float(0.1)

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

type(fraction) == float #True

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

Комплексные числа имеют тип комплекс Отказ

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

complexNumber = 2+3j

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

complexNumber = complex(2, 3)

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

complexNumber.real #2.0
complexNumber.imag #3.0

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

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(0.12) #0

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

round(0.12, 1) #0.1

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

• Математика Пакет предоставляет общие математические функции и константы
• CMATH Пакет предоставляет утилиты для работы со сложными числами.
• Десятичная Пакет предоставляет утилиты для работы с десятическими знаками и номерами плавающих точек.
• Фракции Пакет предоставляет утилиты для работы с рациональными числами.

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

Константы в Питоне

У Python не имеет способа обеспечить применение того, что переменная должна быть постоянной.

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

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

И добраться до каждого значения, используя, например, Константы .width.value Отказ

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

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

WIDTH = 1024

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

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

Перечень в Питоне

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

Использовать enums, импорт Enum от Enum Стандартный библиотечный модуль:

from enum import Enum

Тогда вы можете инициализировать новый Enum таким образом:

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

Как только вы сделаете это, вы можете ссылаться Государственный. Ирактивный и Государство. Активно И они служат постоянными.

Теперь, если вы попытаетесь распечатать Государство. Активно Например:

print(State.ACTIVE)

Это не вернет 1 , но Государство. Активно Отказ

То же значение может быть достигнуто по номеру, назначенному в Enum: Печать (штат (1)) вернется Государство. Активно Отказ То же самое для использования квадратных скобок обозначения Состояние [«активный»] Отказ

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

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

list(State) # [, ]

Вы можете считать их:

len(State) # 2

Пользователь ввод в Python

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

name = "Roger"
print(name)

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

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

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

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

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

Управление операторами в Python

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

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

condition = True

if condition == True:
    # do something

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

Что такое блок? Блок состоит в том, что имеет отступ один уровень (обычно 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")

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

condition = True

if condition == True:
    print("The condition")
    print("was True")
else:
    print("The condition")
    print("was 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 = 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")

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

Пример:

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

Списки в Python

Списки являются существенной структурой данных Python.

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

Например:

dogs = ["Roger", "Syd"]

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

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

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

print("Roger" in items) # True

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

items = []

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

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

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

items[0] = "Roger"

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

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

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

items[-1] # True

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

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

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

len(items) #4

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

items.append("Test")

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

items.extend(["Test"])

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

items += ["Test"]

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

Совет: с продлить () или + = Не забывайте квадратные скобки. Не делай Предметы или items.extend («тест») Или Python добавит 4 отдельных символа в список, что приведет к [«Роджер», 1, «Сид», правда, «T», «E», ',' T ']

Удалите элемент, используя Удалить () Метод:

items.remove("Test")

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

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

#or

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

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

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

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

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

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

Сортируйте список, используя Сортировать () Метод:

items.sort()

Совет: Сортировка () будет работать только, если список содержит значения, которые можно сравнить. Строки и целые числа, например, не могут сравниться, и вы получите ошибку, как TypeError: «<» не поддерживается между экземплярами «int» и 'STR' Если вы пытаетесь.

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

items.sort(key=str.lower)

вместо.

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

itemscopy = items[:]

или использовать отсортировано () Глобальная функция:

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

Это вернет новый список, отсортировал вместо модификации исходного списка.

Кортежи в Питоне

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

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

Они созданы как можно подобно спискам, но с помощью скобок вместо квадратных скобок:

names = ("Roger", "Syd")

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

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

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

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

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

names[-1] # True

Вы можете посчитать элементы в кортеж с Лен () Функция:

len(names) # 2

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

print("Roger" in names) # True

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

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

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

len(names) #2

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

sorted(names)

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

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

Словари в Python

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

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

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

dog = { 'name': 'Roger' }

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

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

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

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

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

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

dog['name'] = 'Syd'

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

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

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

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

PopiTem () Метод извлекает и удаляет последнюю пару ключ/значение, вставленную в словарь:

dog.popitem()

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

'name' in dog # True

Получите список с ключами в словаре, используя Клавиши () Метод, передавая свой результат к Список () конструктор:

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

Получите значения, используя Значения () Метод и пары ключа/ценности пары используют Предметы () Метод:

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

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

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

len(dog) #2

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

dog['favorite food'] = 'Meat'

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

del dog['favorite food']

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

dogCopy = dog.copy()

Наборы в Python

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

Мы можем сказать, что они работают как кортежи, но они не заказываются, и они являются Meatable Отказ

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

У них также есть неизменяемая версия, называемая 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'}

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

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

isSuperset = set1 > set2 # True

Вы можете посчитать элементы в комплекте с Лен () Глобальная функция:

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

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

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

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

print("Roger" in names) # True

Функции в Python

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

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

Вот пример функции называется Привет Это печатает “привет!”:

def hello():
    print('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

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

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

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

Когда функция соответствует Возвращение Заявление, функция заканчивается.

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

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

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

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

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

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

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

В этом случае призывает Здравствуйте ('Syd') Возвращаемое значение – кортеж, содержащий эти 3 значения: («Сид», «Роджер», 8) Отказ

Объекты в Питоне

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

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

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

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

age = 8

возраст Теперь имеет доступ к свойствам и методам, определенным для всех 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

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

Некоторые объекты являются Meatable , в то время как другие – неизменный Отказ Это зависит от самого объекта.

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

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

age = 8
age = age + 1

#or

age += 1

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

Петли в Питоне

Петли являются одной неотъемлемой частью программирования.

В Python у нас есть 2 вида петлей: Пока петли и для петлей Отказ

В то время как петли в Python

в то время как петли определяются с помощью в то время как Ключевое слово, и они повторяют свой блок, пока состояние не будет оценено как Ложь :

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

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

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

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

print("After the loop")

Для петель в Python

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

Например, мы можем повторить предметы в списке:

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

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

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

Диапазон (4) Создает последовательность, которая начинается с 0 и содержит 4 пункта: [0, 1, 2, 3] Отказ

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

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

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

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

Продолжить Останавливает текущую итерацию и рассказывает Python, чтобы выполнить следующий.

Перерыв В целом останавливает петлю и продолжается с следующей инструкцией после окончания контура.

Первый пример здесь печатает 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 :
    # my class

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

class Dog:
    # the Dog class

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

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

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

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

roger = Dog()

Сейчас Роджер это новый объект типа собаки.

Если вы запустите

print(type(roger))

Вы получите <класс '__main __. Собака'>

Специальный тип метода, __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!'

Одной из важных особенностей классов является наследство.

Мы можем создать класс животных с помощью метода прогулка () :

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

И класс собаки может наследовать от животного:

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

Теперь создание нового объекта класса Собака будет иметь прогулка () Метод, как это унаследовано от Животное :

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

Модули в Python

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

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

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

Файл собака Содержит этот код:

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

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

import dog

dog.bark()

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

from dog import bark

bark()

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

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

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

Предположим, вы положите собака в оформлении lib подпапка.

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

Теперь вы можете выбрать – вы можете импортировать собака от lib :

from lib import dog

dog.bark()

или вы можете ссылаться на собака Модуль специфической функции Импорт из lib.dog :

from lib.dog import bark

bark()

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

Python разоблачает много встроенного функциональности через его Стандартная библиотека Отказ

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

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

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

• Математика для математических коммунальных услуг
• Re Для регулярных выражений
• JSON работать с JSON
• datetime работать с датами
• SQLite3 использовать sqlite.
• ОС Для операционной системы утилиты
• Случайные для произвольного количества генерации
• статистика для статистических утилит
• Запросы Для выполнения запросов HTTP Networks
• http Для создания HTTP-серверов
• Урлыб управлять URL-адресами

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

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

import math

math.sqrt(4) # 2.0

или же

from math import sqrt

sqrt(4) # 2.0

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

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

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

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

Python определяет свои конвенции в руководстве по стилю Pep8. Подставки для Предложения Python Englanceement И это место, где все улучшения языка 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)
• Имена классов капитализированы, отдельные слова написаны с заглавной буквой, (камера)
• Имена пакетов строчные и не имеют подчеркивания между словами
• Переменные, которые не должны меняться (константы) записываются в верхнем регистре
• Переменные имена должны быть значимыми
• Добавьте полезные комментарии, но избегать очевидных комментариев
• Добавить пробелы вокруг операторов
• Не используйте ненужные пробелы
• Добавьте пустую строку перед функцией
• Добавьте пустую строку между методами в классе
• Внутри функций/методов, пустые строки могут быть использованы для разделения связанных блоков кода, чтобы помочь читабельности

Отладка в 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 предлагает несколько способов обрабатывать аргументы, передаваемые, когда мы вызываем программу из командной строки.

До сих пор вы запускаете программы либо от REFL, либо используете

python .py

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

python .py 
python .py  

Основной способ справиться с этими аргументами – использовать 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 красный

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

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

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

Есть больше вариантов, но это основы.

И есть сообщество пакетов, которые обеспечивают эту функциональность, как Нажмите и Python Prompt Toolkit Отказ

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

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

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

lambda  : 

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

Эта разница важна. Выражение возвращает значение, оператор не делает.

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

lambda num : num * 2

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

lambda a, b : a * b

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

multiply = lambda a, b : a * b

print(multiply(2, 2)) # 4

Утилита функций лямбда приходит в сочетание с другими функциями 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

Если внутри факториал () Функция, которую вы звоните факториал (n) вместо факториал (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')

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

def count():
    count = 0

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

    increment()

count()

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

Закрытие в Питоне

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

Вот простой пример счетчика.

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

Мы возвращаем увеличение () Внутренняя функция, и это все еще имеет доступ к состоянию Считать переменная, даже если счетчик () Функция закончилась.

Декораторы в Питоне

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

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

Пример:

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

Это Привет Функция имеет Logtime декоратор назначен.

Всякий раз, когда мы называем Привет () Декоратор будет вызван.

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

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

Docstrings в Python

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

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

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

# this is a comment

num = 1 #this is another comment

Еще один способ использовать Docstrings Отказ

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

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

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

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

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

Документируйте модуль, поместив DOCSTRING в верхней части файла, например, предположить, что это собака:

"""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!')

Docstrings может охватывать несколько строк:

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

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

Например, звонок Помощь (приращение) даст вам это:

Help on function increment in module
__main__:

increment(n)
    Increment
    a number

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

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

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

Анноспекция в Питоне

Функции, переменные и объекты могут быть проанализированы с использованием самоанализ Отказ

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

Затем вы можете использовать Print (), чтобы получить информацию о функции:

def increment(n):
    return n + 1

print(increment)

# 

или объект:

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

roger = Dog()

print(roger)

# <__main__.Dog object at 0x7f42099d3340>

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

print(type(increment))
# 

print(type(roger))
# 

print(type(1))
# 

print(type('test'))
# 

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

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

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

Аннотации в Питоне

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

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

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

def increment(n):
    return n + 1

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

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

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

count: int = 0

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

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

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

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

Если вы оберните строки кода в Попробуйте: блокировать:

try:
    # some lines of code

Если возникает ошибка, Python предупредит вас, и вы можете определить, какая ошибка произошла с использованием кроме Блоки:

try:
    # some lines of code
except :
    # handler 
except :
    # handler 

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

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

еще Блок работает, если бы исключения не были найдены:

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

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

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

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

Например, если вы читаете файл, вы можете получить EOFERROR Отказ Если вы разделите номер на ноль, вы получите ZerodivisionError Отказ Если у вас есть проблема преобразования типа, вы можете получить Типеррор Отказ

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

result = 2 / 0
print(result)

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

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

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

Добавление этой работы в Попробуйте: Блок позволяет нам восстановить изящно и перейти к программе:

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

print(result) # 1

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

raise Exception('An error occurred!')

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

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

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

class DogNotFoundException(Exception):
    pass

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

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

С заявлением в Python

с Заявление очень полезно упростить работу с обработкой исключения.

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

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

Вместо письма:

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)

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

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

Как установить 3-я пакеты вечеринки в Python, используя PIP

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

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

Эти модули все собраны в одном месте, Индекс пакета Python Доступно в https://pypi.org , и они могут быть установлены на вашей системе, используя Пип Отказ

Существует более 270 000 пакетов, свободно доступных на момент написания.

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

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

pip install 

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

python -m pip install 

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

pip install requests

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

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

На MacOS, бегущий Python 3.9, расположение – /Library/frameworks/python.framework/versions/3.9/lib/ypackon3.9/site-packages Отказ

Обновите пакет до последней версии:

pip install –U 

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

pip install ==

Удалить пакет с использованием:

pip uninstall 

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

pip show 

Список состоится в Python

Попределения списка – это способ создания списков очень лаконичным способом.

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

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

Вы можете создать новый список, используя понимание списка, состоит из Числа Список элементов, мощность 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)

и над карта () :

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

Полиморфизм в Питоне

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

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

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

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

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

animal1 = Dog()
animal2 = Cat()

animal1.eat()
animal2.eat()

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

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

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

Давайте возьмем класс собаки:

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

Давайте создадим 2 объекта собаки:

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

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

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

Теперь, если вы попробуете работать Печать (Roger> Syd) Вы получите результат Правда Отказ

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

• __eq __ () проверить на равенство
• __LT __ () Чтобы проверить, следует ли считаться объектом ниже другого с < оператор
• __le __ () Для более низких или равных ( <= )
• __ge __ () для большего или равна ( > = )
• __ne __ () Для не равных ( ! = )

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

• __add __ () Ответить на + оператор
• __sub __ () Ответить на - оператор
• __mul __ () Ответить на * оператор
• __truediv __ () Ответить на / оператор
• __flooordiv __ () Ответить на // оператор
• __mod __ () Ответить на % оператор
• __Pow __ () Ответить на ** оператор
• __rshift __ () Ответить на >> оператор
• __lshift __ () Ответить на << оператор
• __ и __ () Ответить на & оператор
• __OR __ () Ответить на |. оператор
• __xor __ () Ответить на ^ оператор

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

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

В вашей системе распространяется несколько приложений Python.

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

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

Мы будем использовать Венв Отказ Другие инструменты работают аналогично, как Пипенв Отказ

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

python -m venv .venv

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

Затем бегите

source .venv/bin/activate

Использовать Источник .Венв/bin/atcivate.fish на раковине рыбы

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

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

➜ папка

к

(.venv) ➜ папка

Сейчас работает Пип будет использовать эту виртуальную среду вместо глобальной среды.

Заключение

Большое спасибо за прочтение этой книги.

Я надеюсь, что это вдохновит вас узнать больше о Python.

Для получения дополнительной информации о учебниках Python и программирования в целом, проверьте мой блог flaviocopes.com Отказ

Отправить любые отзывы, ошибки или мнения на mailto: flavio@flaviocopes.com , и вы можете связаться со мной в Twitter @flaviocopes Отказ

Примечание: вы можете Получите PDF, EPUB и MOBI версию этого справочника Python