Какие символы нельзя использовать в именах программ и переменных

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

• В именах разрешено использовать только алфавитные символы. цифры и символ подчеркивания( _ )
• Первым символом имени не должна быть цифра
• Символы в верхнем и нижнем регистре рассматриваются как разные
• В качестве имени нельзя использовать ключевое слово C++.
• На длину имени не накладываются никакие ограничения, и все символы в имени являются значащими. Однако некоторые платформы, могут накладывать ограничения
• Имена, которые начинаются с двух или с одного символа подчеркивания и следующей за ним буквы в верхнем регистре, зарезервированы для использования реализациями C++, по-другому с ними имеют дело компиляторы и ресурсы.

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

LEGB-rule. Как Python ищет имена переменных

int poodle; // допустимое
int Poodle; // допустимое (отличается от предыдущего имени)
int POODLE; // допустимое(отличается от других двух имен)
Int terrier; // недопустимое вместо Int, нужно использовать int
int my_stars3; // допустимое
int _Mystars3; // допустимое, но зарезервированное
int 4ever; // недопустимое, начинается с цифры
int double; // недопустимое, ключевое слово в C++ double
int begin;// допустимое, не является ключевым словом
int _fools;// допустимое, но зарезервированное
int the_very_best_variable_i_can_be_version_112; // допустимое
int honky-tonk; // недопустимое, дефисы не разрешены

Целочисленные типы

Целыми являются числа без дробной части, к примеру 35,1,404,-531,0. Язык может представить только подмножество целых чисел. C++ предоставляет несколько вариантов. Благодаря этому вы можете выбрать такой целочисленный тип, который будет лучше всего отвечать конкретным требованиям программы. Они различаются друг от друга объемом памяти, выделяемой для хранения целого значения.

Чем больше объем памяти, тем шире диапазон представляемых целочисленных значений. Некоторые типы могут представлять из себя диапазон положительных, так и отрицательных значений(со знаком). А другие только положительные(без знака).

Целочисленные типы short, int, long, long long

Память компьютера состоит из единиц — биты. Используются различное количество битов для хранения значений, типы short,int,long,long long могут представлять до четырех различных целочисленных диапазонов. Не все так просто. Каждый тип имеет определенную ширину.

Тип short имеет ширину не менее 16 битов;

Тип int как минимум такой же, как short;

Тип long имеет ширину не менее 32 битов и как минимум такой же, как int;

Тип long long имеет ширину не менее 64 битов и как минимум такой же, как long;

Максимальные значения и байты целочисленных типов

ЧТО ТАКОЕ ПЕРЕМЕННАЯ В C# | ОБЪЯВЛЕНИЕ И ИНИЦИАЛИЗАЦИЯ ПЕРЕМЕННЫХ | ПРИСВОЕНИЕ ЗНАЧЕНИЙ | C# Урок #4

• Байты:i
  nt 4 байта
  short 2 байта
  long 4 байта
  long long 8 байтов
• Максимальные значения:
  int — 2147483647
  short — 32767
  long 2147483647
  long long — 9223372036854775807

Типы без знаков

Каждый из только что рассмотренных четырех целочисленных типов имеет беззнаковую версию, которая не может хранить отрицательные значения, За счет этого можно увеличить наибольшее значение, которое способна хранить переменная. К примеру тип short представляет диапазон значений от -32768 до 32767, а его беззнаковый вариант представляет диапазон от 0 до 65535. Чтобы создать беззнаковую версию надо использовать ключевое слово unsigned. Вот примеры:

unsigned short // тип short без знака
unsigned int // тип int без знака
unsigned quarterback // тоже тип int без знака
unsigned long // типlong без знака
unsigned long long // тип long long без знака

Приведу пример программы:

*знак решетки*include // определяет INT_MAX как наибольшее значение int

*знак решетки*define ZERO 0 // создает символ zero для значения 0

Источник: dzen.ru

2. Переменные

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

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

Простейшее определение переменной — это именованный контейнер для данных, к которым нужно обращаться в программе. Есть 2 основные причины для этого:

• Зачастую данные — это больше чем 2 символа.
• Обычно к ним нужно обращаться по несколько раз.

Где используется?

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

Правила использования

1. При присвоении значения переменная всегда находится слева, а данные — справа.
2. Имя переменной может начинаться с символа или нижнего подчеркивания ( _ ).
3. Для вывода значения переменной с помощью функции print нужно передавать ее без кавычек.

Частые ошибки

1. Начинать имя переменной с цифры.
2. Использовать символы (кроме нижнего подчеркивания) в имени переменной.
3. Использовать в переменной пробелы.

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

Предположим, что есть большое число: 149597970 . Оно обозначает расстояние между Солнцем и Землей в километрах.

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

>>> sun_to_earth = 149597970
>>> sun_to_earth = sun_to_earth + 1
>>> print(sun_to_earth)
149597971

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

Разберем код примера:

1. Сначала создается переменная sun_to_earth , и ей присваивается значение 149597970.
2. Переменной sun_to_earth присваивается новое значение — 149597971.
3. Выполняется функция print , которая выводит текущее значение переменной, то есть, 149597971.

Советы:

1. Название переменной всегда расположено слева при присваивании. А значение, которое нужно присвоить, располагается справа.
2. В Python (и любом другом языке программирования) очень важно правильно выбирать название переменной, ведь к ней придется часто обращаться:
3. Кое-какие названия являются зарезервированными в Python, поэтому их использовать нельзя: print, true, false, count, sum и так далее. Со временем вы все их узнаете.
4. Названия переменных должны начинаться с символа алфавита или нижнего подчеркивания.
5. Если начать переменную с символа или нижнего подчеркивания, то после в нее можно включать и цифры.
6. Названия переменных чувствительны к регистру. Если был использован символ в верхнем регистре, то именно так и нужно обращаться к переменой в будущем.
7. Практические соглашения именования переменных:
8. Можно добавлять небольшой суффикс, чтобы не путать переменную с ключевым словом Python: var_number , var_true , v_start , v_close, the_class, the_one, the_name. Креативность разрешена, главное, чтобы система оставалась понятной.
9. Лучше не использовать переменную в один символ, только если это цикл или любая другая короткая операция. Такие имена как a, x, y, z начинают путать уже спустя пару минут после того, как их впервые использовали.
10. Слова рекомендуется разделять нижним подчеркиванием: cars_сounted, doors_сlosed, dogs_saved, ships_fixed и так далее. Это повышает читаемость переменных. Сравните: timeinmoscow и time_in_moscow.
11. Рекомендуется (часто требуется) использовать латиницу и английские слова. Так ваш код будут понимать больше разработчиков.

>>> dogs_name = «Шарик»
>>> dogs_kind = «Сенбернар»
>>> print(«Его зовут » , dogs_name , «. Он «, dogs_kind, «.», sep=»»)
Его зовут Шарик. Он Сенбернар.

Это отличный пример применения не только переменной, но и функции print , ведь в последней используются сразу текст и значение переменной. Плюс, названия переменных выбраны очень удачно. Названия для переменных — тема субъективная, поэтому достаточно использовать то, что удобно для вас.

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

Источник: pythonru.com

Соглашения об именах в Python

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

Главный принцип: Имена, которые видны пользователю как открытые части API, должны соответствовать соглашениям, которые отражают использование, а не реализацию.

Описание стилей именования в языках программирования:

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

Следующие стили именования обычно различаются:

• b (одна строчная буква)
• B (одна заглавная буква)
• lowercase (в нижнем регистре)
• lower_case_with_underscores (нижний регистр с подчеркиванием)
• UPPERCASE (в верхнем регистре)
• UPPER_CASE_WITH_UNDERSCORES (верхний регистр с подчеркиванием)
• CapitalizedWords (или CapWords , или CamelCase — так названы из-за неровного вида его букв). Это также иногда называют StudlyCaps .
  Примечание. При использовании аббревиатур в CapWords используйте заглавные буквы заглавных букв. Таким образом, HTTPServerError лучше, чем HttpServerError .
• mixedCase (отличается от CapitalizedWords начальным символом в нижнем регистре!)
• Capitalized_Words_With_Underscores (некрасиво!)

Существует также стиль, в котором используется короткий уникальный префикс, для группировки связанных имен. Это мало используется в Python, но упоминается для полноты. Например, функция os.stat() возвращает кортеж, элементы которого обычно имеют имена, такие как st_mode , st_size , st_mtime и так далее. (Это сделано для того, чтобы подчеркнуть соответствие с полями структуры системного вызова POSIX, что помогает программистам в этом разбираться.)

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

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

• _single_leading_underscore : для внутреннего использования. Например, from M import * не импортируются объекты, имена которых начинаются с подчеркивания.
• single_trailing_underscore_ : используется по соглашению, чтобы избежать конфликтов с ключевыми словами Python, например

Tkinter.Toplevel (master, class_=’ClassName’)

Соглашения об именах в Python.

Имена, которых следует избегать:

Никогда не используйте символы l (строчная буква L ), O (заглавная буква o ) или I (заглавная буква i ) в качестве имен переменных из одного символа.

В некоторых шрифтах эти символы неотличимы от цифр один и ноль. Когда возникает искушение использовать l , используйте L .

Совместимость с ASCII:

Идентификаторы, используемые в стандартной библиотеке должны быть ASCII совместимы, как описано в разделе политики в PEP 3131.

Имена пакетов и модулей:

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

Так как имена модулей отображаются в именах файлов, а некоторые файловые системы являются нечувствительными к регистру символов и обрезают длинные имена, очень важно использовать достаточно короткие имена модулей — это не проблема в Unix, но, возможно, код окажется непереносимым в старые версии Windows, Mac, или DOS.

Когда модуль расширения, написанный на C или C++, имеет сопровождающий модуль Python, который содержит интерфейс более высокого уровня (например, более объектно-ориентированный), модуль начинается с символа подчеркивания (например _socket ).

Имена классов:

Имена классов должны обычно использовать соглашение CapWords .

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

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

Имена типов переменных:

Имена типов переменных, представленные в PEP 484, должны обычно использовать CapWords, предпочитая короткие имена: T , AnyStr , Num . Рекомендуется добавить суффиксы _co или _contra к переменным, используемым для объявления ковариантного или контравариантного поведения соответственно:

from typing import TypeVar VT_co = TypeVar(‘VT_co’, covariant=True) KT_contra = TypeVar(‘KT_contra’, contravariant=True)

Имена исключений:

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

Имена глобальных переменных:

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

Модули, спроектированные для использования с помощью from M import * , должны использовать механизм __all__ для предотвращения экспорта глобальных файлов или использовать более старое соглашение о добавлении префиксов для таких глобальных символов с подчеркиванием (что может потребоваться для указания того, что эти глобальные переменные являются «непубличными модулями»).

Имена функций:

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

Имена переменных следуют тому же соглашению, что и имена функций.

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

Аргументы функций и методов:

Всегда используйте self в качестве первого аргумента для методов экземпляра.

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

Если имя аргумента функции конфликтует с зарезервированным ключевым словом, обычно лучше добавить одно завершающее подчеркивание, а не использовать сокращение или орфографическое искажение. Таким образом, class_ лучше, чем clss . (Возможно, лучше избегать таких столкновений, используя синоним.)

Имена методов и переменных экземпляра класса:

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

Используйте одно начальное подчеркивание только для закрытых методов и переменных экземпляра.

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

Python связывает эти имена с именем класса: если класс Foo имеет атрибут с именем __a , Foo не сможет получить к нему доступ как Foo.__a . (Настойчивый пользователь все еще может получить доступ, вызвав Foo._Foo__a .) Как правило, двойные начальные подчеркивания должны использоваться только во избежание конфликтов имен с атрибутами в классах, предназначенных для подклассов.

Примечание: есть некоторые противоречия по поводу использования __names (см. Ниже).

Константы:

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

Проектирование наследований:

Всегда решайте, должны ли методы класса и его экземпляра («атрибуты класса») быть открытыми или закрытыми. В случае сомнений, выберите закрытый. Проще сделать его общедоступным позже, чем сделать общедоступный атрибут закрытым.

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