Самоучитель
Переменные в Python для начинающих
Любая программы состоит из набора команд и данных. Так вот, чтобы хранить данные, в любом языке программирования, и Python не исключение, есть такое понятие как переменные.
Переменная это не что иное, как имя, с помощью которого можно обратиться к данным, сохраненным в памяти компьютера. Другими словами, переменная — это именованная область памяти. Чтобы создать переменную и назначить ей значение используется оператор присваивания. Вот несколько примеров того, как создается, или, как говорят программисты, «объявляется» переменная
Синтаксис «объявления» прост: достаточно написать имя переменной, знак «=» и значение переменной. У разных переменных могут быть разные типы данных. В нашем примере переменная first является строкой, а переменная second — числом. В Python, кроме строк и чисел, есть и другие типы данных. Если вы начинающий программист и не знаете, что такое типы данных, не переживайте, об этом будет рассказано чуть позже.
Самое простое, что можно сделать с переменной, это вывести на экран ее значение.
Попробуйте запустить такую программу и посмотрите, что она выведет на экран.
Имена переменных
Следует придерживаться нескольких несложных правил при выборе имен переменных:
Имя переменной может содержать только латинские буквы, числа и символ нижнего подчеркивания;
Имя переменной не должно содержать пробелов;
Имя переменной не должно начинаться с цифры;
Регистр важен: var и Var это разные переменные.
Называя переменные помните, что имена переменных не должны совпадать с ключевыми словами и наименованиями встроенных функций. Их использование в языке Python предназначено для других целей, которые нам с вами предстоит узнать позже и называть так переменные нельзя.
Будучи единоличным хозяином своей программы, вы вправе выбирать имена переменным. В прошлой статье я решил назвать переменную name, но с тем же успехом можно было бы ее именовать human, nickname или даже omega12345666: работа программы нисколько не изменилась бы.
Для создания корректных имен переменных надо следовать всего нескольким правилам; о некорректном имени Python вам сообщит, выведя ошибку.
Итак, важнейших правил два:
Вдобавок к этим двум абсолютным законам есть несколько негласных правил, которым следуют все опытные программисты.
Вы тоже, приобретя некоторый опыт, почувствуете разницу между «просто корректными» и «хорошими» именами переменным(приведу пример прямо сейчас: имя omega12345666 — корректное, но очень, очень плохое). Перечислю основное, что надо и нужно запомнить.
Имя должно описывать суть. Следует называть переменные так, чтобы другой программист, взглянув на ваш код, смог толком разобраться, что есть что. Поnэтому, например, score лучше, чем s.
Исключение — кратковременно действующие переменные, которым программисты склонны присваивать короткие имена, например х. Но даже этот случай нельзя считать подлинным исключением, ведь, называя переменную х, программист дает понять, что она временная.
Будьте последовательны. Есть много разных позиций по вопросу о том, как лучше оформлять имена переменных, составленные из нескольких слов. Будет ли лучше, например, написать high_score или highScore?
Я привык пользоваться подчеркиванием.Отнюдь не важно, какой системы вы придерживаетесь, лишь бы вы следовали все время только ей, хотя по стандарту оформления программ правильно использовать для переменных и функций именно подчеркивания.
Уважайте обычай языка. Некоторые правила именования переменных — всего лишь дань традиции. Так, в большинстве языков программирования, в том числе и в Python, имя переменной принято начинать со строчной буквы.
Другая традиция состоит в том, чтобы избегать подчеркиваний в качестве начальных символов в именах переменных (у имен с начальным подчеркиванием в Python особый смысл).
Следите за длиной. Иногда эта рекомендация может вступать в противоречие с первой, требующей от имен переменных описательной силы. В самом деле, разве удобно пользоваться таким, например, именем: persona1_checking_account_bаlance’? Видимо, нет.Чересчур длинные имена переменных проблематичны, в частности, тем, что загромождают код.
А кроме того, чем длиннее имя, тем выше риск сделать в нем опечатку. Советую вам не создавать имена длиннее 15 символов.
Кстати, самодокументирующим называется код, из которого даже без комментариев легко понять, что происходит в программе. «Говорящие» имена переменных — немаловажный шаг на пути к созданию такого кода.
Вот что случится если объявить переменную ошибочно, то есть начать переменную с цифрами:
Соглашения об именах в Python
Как называть переменные и объекты в коде
Соглашения об именах библиотеки Python немного беспорядочные, поэтому мы никогда не получим полное согласование. Тем не менее, вот рекомендуемые в настоящее время стандарты именования. Новые модули и пакеты (включая сторонние фреймворки) должны быть написаны в этих стандартах, но там, где существующая библиотека имеет другой стиль, внутренняя согласованность предпочтительнее.
Главный принцип: Имена, которые видны пользователю как открытые части API, должны соответствовать соглашениям, которые отражают использование, а не реализацию.
Описание стилей именования в языках программирования:
Есть много разных стилей именования. Это помогает понять, какой стиль именования используется независимо от того, для чего он используется.
Следующие стили именования обычно различаются:
Библиотека X11 использует ведущий X для всех своих публичных функций. В Python этот стиль обычно считается ненужным, потому что имена атрибутов и методов начинаются с префикса объекта, а имена функций начинаются с имени модуля.
Кроме того, распознаются следующие специальные формы с использованием начальных или конечных подчеркиваний (обычно они могут сочетаться с любым соглашением по случаю):
_single_leading_underscore : для внутреннего использования. Например, from M import * не импортируются объекты, имена которых начинаются с подчеркивания.
single_trailing_underscore_ : используется по соглашению, чтобы избежать конфликтов с ключевыми словами Python, например
__double_leading_underscore : изменяет имя атрибута класса (внутри класса FooBar __boo становится _FooBar__boo ).
Соглашения об именах в Python.
Имена, которых следует избегать:
Никогда не используйте символы l (строчная буква L ), O (заглавная буква o ) или I (заглавная буква i ) в качестве имен переменных из одного символа.
Совместимость с ASCII:
Идентификаторы, используемые в стандартной библиотеке должны быть ASCII совместимы, как описано в разделе политики в PEP 3131.
Имена пакетов и модулей:
Модули должны иметь короткие, строчные имена. Подчеркивания могут использоваться в имени модуля, если это улучшает читабельность. Пакеты Python также должны иметь короткие, строчные имена, хотя использование подчеркивания не рекомендуется.
Когда модуль расширения, написанный на C или C++, имеет сопровождающий модуль Python, который содержит интерфейс более высокого уровня (например, более объектно-ориентированный), модуль начинается с символа подчеркивания (например _socket ).
Имена классов:
Соглашение об именовании для функций может использоваться вместо этого в случаях, когда интерфейс задокументирован и используется в основном как вызываемый.
Обратите внимание, что для встроенных имен существует отдельное соглашение: большинство встроенных имен представляют собой отдельные слова (или два слова, идущие вместе), причем соглашение CapWords используется только для имен исключений и встроенных констант.
Имена типов переменных:
Имена исключений:
Поскольку исключения должны быть классами, здесь применяется соглашение об именах классов. Однако вы должны использовать суффикс Error в именах исключений (если исключение на самом деле является ошибкой).
Имена глобальных переменных:
Будем надеяться, что эти переменные предназначены для использования только внутри одного модуля. Соглашения примерно такие же, как и для функций.
Имена функций:
Имена функций должны быть строчными, слова должны быть разделены подчеркиванием, чтобы улучшить читаемость.
Имена переменных следуют тому же соглашению, что и имена функций.
mixedCase допускается только в тех случаях, когда уже преобладает такой стиль, для сохранения обратной совместимости.
Аргументы функций и методов:
Всегда используйте self в качестве первого аргумента для методов экземпляра.
Всегда используйте cls в качестве первого аргумента для методов класса.
Имена методов и переменных экземпляра класса:
При необходимости используйте правила именования функций: строчные буквы со словами, разделенными подчеркиванием, чтобы улучшить читаемость.
Используйте одно начальное подчеркивание только для закрытых методов и переменных экземпляра.
Чтобы избежать конфликта имен с подклассами, используйте два ведущих подчеркивания для вызова правил искажения имен в Python.
Примечание: есть некоторые противоречия по поводу использования __names (см. Ниже).
Константы:
Проектирование наследований:
Всегда решайте, должны ли методы класса и его экземпляра («атрибуты класса») быть открытыми или закрытыми. В случае сомнений, выберите закрытый. Проще сделать его общедоступным позже, чем сделать общедоступный атрибут закрытым.
Мы не используем термин «приватный», поскольку ни один атрибут не является таковым в Python.
Имея это в виду, вот данные руководящие принципы:
Публичные атрибуты не должны иметь начальных подчеркиваний.
Если имя вашего общедоступного атрибута вступает в противоречие с зарезервированным ключевым словом, добавьте к его имени один завершающий символ подчеркивания. Это предпочтительнее аббревиатуры или искаженного написания. (Однако, несмотря на это правило, cls является предпочтительным написанием для любой переменной или аргумента, который, как известно, является классом, особенно первым аргументом для метода класса.)
Примечание 1: См. Рекомендацию выше имени аргумента для методов класса.
Примечание 1: Свойства properties работают только с классами нового стиля.
Примечание 2: Старайтесь не допускать побочных эффектов функционального поведения, хотя, такие как кэширование, обычно хороши.
Примечание 3: Избегайте использования в свойствах дорогих операций, так как нотация атрибута заставляет пользователя класса думать, что доступ (относительно) дешев.
Если ваш класс предназначен для использования в подклассах (наследование), и у вас есть атрибуты, которые вы не хотите использовать в наследовании, рассмотрите возможность присвоения им имен с двойным нижним подчеркиванием и без завершающего подчеркивания. Это вызывает алгоритм искажения имени Python, где имя класса искажается в имя атрибута. Это помогает избежать конфликтов имен атрибутов, если подклассы непреднамеренно содержат атрибуты с одинаковыми именами.
Примечание 1: Обратите внимание, что в искаженном имени используется только простое имя класса, поэтому, если подкласс выбирает одно и то же имя класса и имя атрибута, вы все равно можете получить конфликты имен.
Примечание 3: не всем нравится искажение имени. Постарайтесь уравновесить необходимость избегать случайных конфликтов имен с потенциальным использованием продвинутыми программистами.
Публичные и внутренние интерфейсы
Любые гарантии обратной совместимости применяются только к общедоступным интерфейсам. Соответственно, важно, чтобы пользователи могли четко различать открытый и внутренний интерфейсы.
Документированные интерфейсы считаются общедоступными, если в документации явно не указано, что они являются временными или внутренними. Такие интерфейсы не гарантируют обратной совместимости. Все недокументированные интерфейсы должны быть внутренними.
Даже при правильной установке __all__ внутренние интерфейсы (пакеты, модули, классы, функции, атрибуты или другие имена) должны по-прежнему иметь префикс с единственным начальным подчеркиванием.
Интерфейс также считается внутренним, если содержащее пространство имен (пакет, модуль или класс) считается внутренним.
Именование в Python — как выбирать имена и почему это важно
Н ачинающие программисты не придают значение именованию переменных при написании кода. Особенно это касается новых проектов — есть какая-то идея, её нужно реализовать и получить результат. Нет времени на то, чтобы задумываться о названиях для переменных, функций, классов и т.п.
Но проект растёт, количество кода увеличивается, и в один прекрасный день разработчик понимает, что 80% его времени уходит на чтение кода и его модификацию (а вовсе не на написание нового кода). Код, написанный неделю назад, кажется незнакомым — приходиться тратить время и силы чтобы вспомнить, что он делает. Плохое именование усугубляет картину:
Минусы такого именования:
Основная суть программирования — это управление сложностью. Поддерживать сотни тысяч строк кода — достаточно сложно. Для уменьшения сложности приложение разбивают на модули, методы и классы. Правильное именование переменных также помогает в управлении сложностью.
Управление сложностью является сущностью компьютерного программирования.
Ниже рассмотрим, как правильно именовать переменные в Python, какую нотацию использовать + кратко рассмотрим стандарт РЕР8.
Допустимые имена переменных в Python
Вы можете придумать любые названия для переменных в Python, но есть несколько правил, которые нужно соблюдать.
Правила для переменных в Python:
Список всех зарезервированных ключевых слов можно посмотреть так:
import keyword print(keyword.kwlist)
Если нарушить правило именования, получим SyntaxError :
3r = 10 print(3r) File «test.py», line 1 3r = 10 ^ SyntaxError: invalid syntax
Нотация в Python: CamelCase или under_score?
Нотация — это соглашение об именовании. Наиболее популярные нотации в программировании — camel case и underscore.
camelCase (еще называется «верблюжья нотация») — это стиль, в котором слова пишутся слитно, а каждое слово начинается с прописной (большой) буквы. Имеется два подвида этого стиля: lowerCamelCase (все слова кроме первого начинаются с прописной буквы) и UpperCamelCase (все слова, в том числе и первое пишутся с большой буквы).
under_score (snake_case) — при использовании этого стиля в качестве разделителя используется символ подчеркивания «_», а все слова начинаются со строчной (маленькой) буквы;
В Python преимущественно используется нотация under_score
Однако under_score — не единственная нотация, рекомендуемая к использованию в Python. Вот гайдлайн по именованию, основанный на рекомендациях Гвидо ван Россума (автора языка Python):
Как выбирать имена для переменных в Python
Основной принцип хорошего именования — имена должны быть содержательными (полностью отражать своё назначение). Перед тем, как дать имя переменной, функции или классу, ответьте на вопросы:
👎 Пример плохого именования:
def area(side1, side2): return side1 * side2 d = area(4, 5)
В данном примере переменная d не обозначает ровным счётом ничего. По названию функции area не понятно, что она делает, какие параметры принимает и что возвращает.
👍 Пример хорошего именования:
def get_rectangle_area(length, width): return length * width area = get_rectangle_area(4, 5)
В примере понятно что делает функция get_rectangle_area (передав длину и ширину, функция вычисляет и возвращает площадь прямоугольника). Результат попадет в переменную area (площадь).
Содержательное имя понятно, легко читается и не требует дополнительных комментариев.
Вот еще несколько рекомендаций по выбору имён в Python:
⚡ Подбирайте имена на английском языке. Не нужно использовать русские имена переменных и писать их транслитом. Для программиста важно знать английский язык.
def proverka_zdorovya(): # плохо pass def health_check(): # хорошо pass
⚡ Для функций используйте глагол (например «купить», «получить», «распечатать»), для переменных, модулей и классов используйте существительное (например «список», «покупатели», «товары»).
Частая ошибок новичков — называть функцию существительным:
def speed_calculator(distance, time): # неправильно (калькулятор скорости) pass def calculate_speed(distance, time): # правильно (рассчитать скорость) pass
⚡ Имена функций должны быть как можно короче. Функция выполняет всего одно действие и именно оно должно отображаться в её имени.
def create_text_utf8_pipe_from_input(): # плохо pass def create_pipe(): # хорошо pass
⚡ Перед именами булевских переменных (и методов, возвращающих тип bool ), добавляйте префикс «is».
def is_goal_state(): # хорошо pass is_active = True # хорошо
⚡ Используйте удобопроизносимые имена. Людям удобно работать со словами. Часть мозга специализируется на обработке слов — нужно использовать эту часть мозга.
# пример плохого именования (имена трудно произносить вслух) class GlobalFRTEV: # плохо def get_any_mdhd(self): # плохо pass def get_any_mdhl(self): # плохо pass def get_any_mdhf(self): # плохо pass
Имена будут использоваться в обсуждении с коллегами. Рассказывать про баг в методе get_any_mdhf класса GlobalFRTEV будет достаточно проблематично.
⚡ Использовать однобуквенные переменные не рекомендуется. Их можно использовать исключительно для локальных переменных в небольших методах.
r = requests.get(‘https://pythonchik.ru’) # плохо response = requests.get(‘https://pythonchik.ru’) # хорошо
⚡ Не нужно разрабатывать и использовать свою систему кодирования имен. Такие имена трудно произносить и в них можно сделать опечатку. К тому же, каждый новый сотрудник должен будет изучать вашу систему кодирования.
tm1_word = «Hello» # плохо
⚡ Также не следует использовать юмор при выборе имени файла. Ведь шутка может быть понятна не всем. Также не рекомендуется использовать каламбуры и сленг.
⚡ Помните, что ваш код будут читать программисты, поэтому используйте слова из профессиональной области, например, названия алгоритмов, паттернов или математические термины. Также полезно использовать слова из предметной области, к которой принадлежит решаемая задача.
💭 Больше полезных сведений о выборе имен идентификаторов и другие советы, которые пригодятся при написании кода, можно найти в книгах:
Именование переменных в PEP8
В стандарте РЕР8 описаны следующие стили именования:
💁♂️ Для удобства, среды разработки (например PyCharm) автоматически проверяют, насколько код соответствует рекомендациям стандарта РЕР8. Если имя идентификатора не будет соответствовать соглашениям, то IDE подчеркнет переменную, а если навести на нее мышку, появится сообщение с подсказкой.
Хороший код документирует сам себя. При правильном именовании, не возникает вопросов по тому, что происходит в отдельных частях кода. И отпадает необходимость писать комментарии к каждой строке.
Чтобы прокачать навык именования переменных, читайте чужой код крупных проектов (например на github). Смотрите, какие имена используют опытные разработчики, анализируйте и применяйте в своих проектах.
Переменные в Python
Переменные — важная часть любого языка программирования. Они позволяют хранить, использовать и передавать данные.
Переменные позволяют не только удобно манипулировать данными, но и разделять их на типы, с которыми можно работать по определённым правилам. В Python они подчиняются концепциям, используемым в других языках программирования, однако они также имеют особенности, например, тип явно не объявляется.
Создание и присвоение значений
Создание переменной в Python 3 отличается от других языков программирования. Её не нужно заранее объявлять, указывать её тип, она создается в момент присваивания значения.
Чтобы создать переменную, используется символ равенства «=». Слева от которого пишут наименование, а справа — значение нужного типа. Пример:
Динамическая типизация
Такое создание переменных возможно благодаря динамической типизации.
Множественное присваивание и обмен значениями
Python позволяет программисту присвоить одно и то же значение нескольким переменным:
Кроме того, в отличие от других языков программирования Python позволяет обменять значения двух переменных —
Такая операция возможна, потому что Python используется кортеж, в который помещает значения, чтобы можно было поменять их местами.
Имена
В именах переменных в Python 3 можно использовать только буквы, цифры и символы подчеркивания. Цифры можно использовать в любой части имени, кроме начала.
И если синтаксис накладывает на программиста мало ограничений, то IT сообщество требует «хороших» имён для переменных:
Для создания хороших имён используются следующие методы:
Зарезервированные имена (ключевые слова)
Вывод в консоль
Чтобы вывести переменную на экран, используют функцию print(). С её помощью можно вывести значение одной или нескольких переменных в форматированном выводе. Есть несколько вариантов синтаксиса вывода:
Пустая переменная
None используется в случаях, когда значение не определено, не существует. И хотя он не эквивалентен какому-либо значению типа bool, строке или числу, он также является объектом.
При необходимости, можно проверить содержимое переменной следующим образом:
Может использоваться, например, когда мы в переменной храним указатель на открытый файл. И когда мы этот файл закрываем, то присваиваем указателю значение None. В дальнейшем можно проверять будет перед записью или чтением данных, является ли переменная пустой.
Области видимости
В Python есть глобальная и локальная область видимости. Объявление переменных в разных областях видимости помогает избежать пересечения имён, открывает программисту новые уровни взаимодействий между ними и делает код более безопасным, делая невозможным несанкционированный доступ к механизмам работы функций.
Глобальная область видимости — это тело исполняемого скрипта. К любой переменной, объявленной в ней, можно получить доступ из любой части программы, даже из другого модуля.
Чтобы получить доступ к глобальной переменной из функции, необходимо использовать ключевое слово global, оно показывает интерпретатору, что нужно использовать находящуюся в глобальной области видимости. Кроме того, если функция не находит в своём теле нужную переменную, она автоматически ищет её в глобальной области видимости скрипта и использует.
Локальная область видимости недоступна для редактирования из вне, любая переменная, объявленная внутри функции будет находиться в локальной области видимости, это позволяет использовать одно и то же имя много раз в одной программе, защитить функцию от ненужных изменений и упростить написание кода.
Удаление
Заключение
Python даёт программисту все необходимое для работы с переменными, он предоставляет и такие инструменты, которых нет в других языках программирования, например, обмен значений.
Python делает работу с переменными очень простой, он позволяет не объявлять их типы, присваивать уже существующей значение другого типа и поддерживает работу с областями видимости.
