Сколько байтов памяти отводится для типа integer: С | Типы данных

Сводка типов данных | Microsoft Learn

Twitter LinkedIn Facebook Адрес электронной почты

• Статья
• 02/04/2023
• Чтение занимает 3 мин

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

Набор встроенных типов данных

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

Тип данных	Размер хранилища	Диапазон
Boolean	2 байта	True или False
Byte	1 байт	от 0 до 255
Collection	Неизвестно	Неизвестно
Currency (масштабируемое целое число)	8 байт	от –922 337 203 685 477,5808 до 922 337 203 685 477,5807
Date	8 байт	от 1 января 100 г. до 31 декабря 9999 г.
Decimal	14 байт	+/–79 228 162 514 264 337 593 543 950 335 без десятичной запятой +/–7,9228162514264337593543950335 с 28 разрядами справа от десятичной запятой Наименьшее ненулевое число равно +/–0,0000000000000000000000000001
Dictionary	Неизвестно	Неизвестно
Double (число с плавающей запятой двойной точности)	8 байт	от –1,79769313486231E308 до –4,94065645841247E-324 для отрицательных значений от 4,94065645841247E-324 до 1,79769313486232E308 для положительных значений
Integer	2 байта	от –32 768 до 32 767
Long (целое число Long)	4 байта	от –2 147 483 648 до 2 147 483 647
LongLong (целое число LongLong)	8 байт	от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 Действительно только для 64-разрядных платформ.
LongPtr (целое число Long в 32-разрядных системах, целое число LongLong в 64-разрядных системах)	4 байта в 32-разрядных системах 8 байт в 64-разрядных системах	от –2 147 483 648 до 2 147 483 647 в 32-разрядных системах от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 в 64-разрядных системах
Object	4 байта	Любая ссылка на Object
Single (число с плавающей запятой одинарной точности)	4 байта	от –3,402823E38 до –1,401298E-45 для отрицательных значений от 1,401298E-45 до 3,402823E38 для положительных значений
String (переменная длина)	10 байтов + длина строки	от 0 до приблизительно 2 миллиардов
String (фиксированная длина)	Длина строки	от 1 до приблизительно 65 400
Variant (с числами)	16 байт	Любое числовое значение до диапазона типа Double
Variant (с символами)	22 байта + длина строки (24 байтов в 64-разрядных системах)	Тот же диапазон как для типа String переменной длины
Определяется пользователем (используя Type)	Число, необходимое для элементов	Диапазон каждого элемента совпадает с диапазоном его типа данных.

Тип Variant, содержащий массив, требует на 12 байт больше, чем сам массив.

Примечание.

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

Например, данные в одномерном массиве, состоящем из 4 элементов данных Integer размером 2 байта каждый занимают 8 байтов. 8 байтов, необходимых для данных, плюс 24 байта служебных данных составляют 32 байта полной памяти, требуемой для массива. На 64-разрядных платформах массив SAFEARRAY занимает 24 бита (плюс 4 байта на оператор Dim). Элемент pvData является 8-байтным указателем, и он должен находиться в границах 8 байтов.

Примечание.

Тип LongPtr не является настоящим типом данных, так как он преобразуется в тип Long в 32-разрядных средах или в тип LongLong в 64-разрядных средах. Тип LongPtr

должен использоваться для представления указателя и обработки значений в операторах Declare и позволяет писать переносимый код, который может выполняться как в 32-разрядных, так и в 64-разрядных средах.

Примечание.

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

Преобразование между типами данных

В статье Функции преобразования типов приведены примеры использования следующих функций для приведения выражения к определенному типу данных: CBool, CByte, CCur, CDate, CDbl, CDec, CInt, CLng, CLngLng, CLngPtr, CSng, CStr и CVar.

Ниже приведены страницы соответствующих функций: CVErr, Fix и Int.

Примечание.

Функция CLngLng действительна только для 64-разрядных платформ.

Проверка типов данных

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

• IsArray
• IsDate
• IsEmpty
• IsError
• IsMissing
• IsNull
• IsNumeric
• IsObject

Возвращаемые значения функции CStr

Если expression	CStr возвращает
Boolean	Строка, содержащая значение True или False.
Date	Строка, содержащая полный или краткий формат даты, установленный в системе.
Empty	Строка нулевой длины («»).
Error	Строка, содержащая слово Error и номер ошибки.
Null	Ошибка во время выполнения.
Другое числовое значение	Строка, содержащая число

См.

также

• Константы VarType
• Ключевые слова по задачам
• Справочник по языку Visual Basic

Поддержка и обратная связь

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

2.8. Данные целого типа (integer)

Тип int – целое число, обычно соответствующее естественному размеру целых чисел. Квалификаторы short и long указывают на различные размеры и определяют объем памяти, выделяемый под них (см. табл. 2.1), например:

short x

;

long x;

unsigned x = 8; – декларация с инициализацией числом 8;

атрибут int в этих случаях может быть опущен.

Атрибуты signed и unsigned показывают, как интерпретируется старший бит числа – как знак или как часть числа:

int	Знак	Значение числа
	15	14 13 12 11 10 9 8 7 6 5 4 3 2 1 0	– номера бит

unsigned int	Значение числа
	15 0

long	Знак	Значение числа
	31	30 0

unsigned long	Значение числа
	31 0

2.

9. Данные символьного типа (char)

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

Для персональных компьютеров (ПК) наиболее распространена ASCII (American Standard Code for Information Interchenge) таблица кодов (см. прил. 1). Данные типа char рассматриваются компилятором как целые, поэтому возможно использование signed char: величины со знаком (по умолчанию) – символы с кодами от –128 до +127 и unsigned char – беззнаковые символы с кодами от 0 до 255. Этого достаточно для хранения любого символа из 256-символьного набора

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

Примеры: char res, simv1, simv2;

char let = ‘s‘; – декларация символьной переменной с инициализацией символом s.

2.10. Данные вещественного типа (float, double)

Данные вещественного типа в памяти занимают (табл. 2.2): float – 4 байта (одинарная точность), double (удвоенная точность) – 8 байт; long double (повышенная точность) – 10 байт. Для размещения данных типа float обычно 8 бит выделено для представления порядка и знака и 24 бита под мантиссу.

Таблица 2.2

Тип	Точность (мантисса)	Порядок
float (4 байта)	7 цифр после запятой	 38
double (8 байт)	15	 308
long double (10 байт)	19	 4932

Типы данных с плавающей десятичной точкой хранятся в оперативной памяти иначе, чем целочисленные. Внутреннее представление вещественного числа состоит из двух частей: мантиссы и порядка (см. разд. 3.2 «Константы вещественного типа»). В IBM совместимых ПК, как вы уже знаете, переменная типа float занимает 4 байта, из которых один двоичный разряд отводится под знак мантиссы, 8 разрядов под порядок и 23 под мантиссу. Мантисса – это число больше единицы и меньше двух. Поскольку старшая цифра мантиссы всегда равна единице, то ее не хранят.

Для величин типа doublе, занимающих 8 байт, под порядок и мантиссу отводится 11 и 52 разряда соответственно. Длина мантиссы определяет точность числа, а порядок – его диапазон. Как можно видеть из приведенных выше таблиц, при одинаковом количестве байт, отводимом под величины типа float и long int, диапазоны их допустимых значений сильно различаются из-за внутренней формы представления значений таких данных.

При переносе программы с одной платформы на другую нельзя делать предположений, например, о типе int, так как для оперативной системы (ОС) MS DOS этот тип имеет размер в два байта, а для ОС Windows 9X – четыре байта. В стандарте ANSI поэтому диапазоны значений для основных типов не задаются, а определяются только соотношения между их размерами, например:

sizeof (float) < sizeof (double) < sizeof (long double) ,

sizeof (char) < sizeof (short) < sizeof (int) < sizeof (long) ,

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

Требования к хранилищу типа данных

— База знаний MariaDB

Содержание

1. Числовые типы данных
   1. Десятичные
2. Строковые типы данных
   1. Примеры
3. Типы данных даты и времени
   1. Микросекунды
      1. MySQL 5.6+ и MariaDB 10.1+
      2. MariaDB 5. 3 — MariaDB 10.0
4. НУЛИ

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

Числовые типы данных

Обратите внимание, что для столбцов MEDIUMINT потребуется 4 байта в памяти (например, в пуле буферов InnoDB).

Десятичное число

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

Строковые типы данных

В приведенных ниже описаниях M — объявленная длина столбца (в символах или байтах), а len — фактическая длина значения в байтах.

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

При использовании поля с атрибутом COMPRESSED для метаданных резервируется 1 байт. Например, VARCHAR(255) будет использовать +2 байта вместо +1.

Примеры

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

Типы данных даты и времени

Микросекунды

В MariaDB 5.3 и MySQL 5.6 введены микросекунды. Базовые реализации хранилища были разными, но начиная с версии MariaDB 10.1, MariaDB по умолчанию использует формат MySQL (с помощью переменной mysql56_temporal_format). Микросекунды имеют следующие дополнительные требования к хранению:

MySQL 5.6+ и MariaDB 10.1+

MariaDB 5.3 — MariaDB 10.0

NULL

Для форматов строк InnoDB COMPACT, DYNAMIC и COMPRESSED количество байтов будет выделено в заголовке записи для полей, допускающих значение NULL. Если имеется от 1 до 8 полей, допускающих значение NULL, будет выделен 1 такой байт. В области полезной нагрузки записи место для значений NULL не резервируется.

Для формата строки InnoDB REDUNDANT накладные расходы составляют 1 бит в заголовке записи (как часть 1-байтового или 2-байтового указателя «конец поля»). В этом формате поле фиксированной длины NULL будет занимать столько же места, сколько и любое значение NOT NULL в области полезной нагрузки записи. Мотивация заключается в том, что возможно обновление на месте между значениями NOT NULL и NULL.

В других форматах для значений NULL обычно требуется 1 бит в файле данных, 1 байт в индексном файле.

Комментарии

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

ProjPython — Переменные и выражения

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

Переменные

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

Утверждение смысл_жизни = 42 называется присвоение переменной , и это заставляет Python делать три вещи:

1. Python резервирует место в памяти для хранения целого числа значения 42.
2. Python дает этому местоположению имя значение_жизни .
3. Python копирует шаблон 0 и 1, соответствующий значению 42, в это место в памяти.

Позже, когда потребуется значение переменной (в операторе print(meaning_of_life) ), центральный процессор компьютера (иногда называемый ЦП) определяет место в памяти, с которым имя value_of_life связывается, переходит в это место и извлекает найденное там значение, делая это значение доступным для Python. Поскольку это значение используется в операторе print , Python выводит значение 42.

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

Имена переменных и строки

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

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

Вскоре мы увидим, как использовать переменные для вычисления и сохранения значений. Но одно из важных применений переменных — изменение поведения кода. Во-первых, мы пишем код в терминах некоторых переменных. Изменение значений этих переменных затем меняет поведение кода. Пример ниже показывает, как это работает. Сначала запустите код. Затем измените значение x на 60 и y на 120 и снова запустите код. Как изменится поведение программы?

Упражнение: широкая улыбка

Цель: Используйте переменные, чтобы упростить изменение поведения кода.

Приведенный ниже код рисует смайлик на экране, и вы можете использовать переменные x и y , чтобы изменить место, где рисуется смайлик. Но смайлик всегда одинакового размера. Добавьте новую переменную scale , которая позволяет изменять размер смайлика, чтобы сделать его больше или меньше. Например, если масштаб имел значение 2 , тогда код отрисовывал смайлик в два раза больше (но по-прежнему центрировался на x и y ).

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

Выбор хороших имен переменных

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

По соглашению все буквы, встречающиеся в именах переменных в Python, должны быть строчными. Если вы хотите составить имя переменной из нескольких слов, используйте символы подчеркивания _ для замены пробелов, как в имени переменной смысл_жизни . (Некоторые программисты предпочитают «верблюжий регистр»: , означающийOfLife . Сейчас не время наносить смелые удары по независимости — вы должны следовать соглашениям Python в своем коде Python, который включает использование символов подчеркивания для разделения слов в именах переменных.)

Присвоение переменной с помощью ‘=’

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

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

В математике x  = 5 — прекрасное уравнение. Так же и x  = 6. Но если бы я дал вам оба уравнения, вы бы сказали, что я облажался, потому что тогда x равнялось бы и 5, и 6, а этого просто не может быть. Но в Python прекрасно работает следующее:

Оператор = в Python означает, что , а не означает «математическое равенство». В Python оператор присваивания , написанный со знаком равенства, делает несколько вещей:

1. Если переменная слева от знака равенства не существует, для этой переменной резервируется место в памяти.
2. Вычисляется выражение справа от знака равенства.
3. Вычисленному значению в правой части присваивается (копируется) место в памяти, отведенное для переменной.

Итак, первая строка кода копирует значение 5 в переменную x . Вторая строка кода копирует значение 6 в переменную x . Когда программа завершена, x имеет значение 6.

Вот несколько утверждений, которые не работают в математике, но работают в Python:

В математике x  =  x  + 1 будет означать что-то вроде « x — это число, которое на единицу больше самого себя». Похоже на то, что капитан Кирк использовал, чтобы заставить компьютер взорваться в Star Trek . Нет такого номера.

В Python нет проблем. Вычислите выражение в правой части. Хорошо — поскольку x имеет значение 5, мы знаем, что x + 1 оценивается как 6. Присвоить это значение для переменной слева. Отлично — теперь переменная x имеет значение 6. Компьютер не взрывается.

Когда вы видите или пишете знак равенства в Python, не думайте, что это «математическое равенство». Произнесите мысленно: «оператор присваивания». Вычислите значение в правой части. Поместите вычисленное значение в переменную с левой стороны.

Будет ли код 5 = x работать в Python? Нет. Левый операнд оператора присваивания должно быть именем переменной. 5 не является именем переменной.

Как работает память

Память в компьютере представляет собой длинную последовательность нулей и единиц, или b inary dig ее : битов. Вы можете представить себе очень длинный ряд переключателей включения/выключения. Поскольку каждое значение переключателя не дает много информации (только 0 или 1), полезно ссылаться на группы битов. Группа из восьми последовательных битов называется байт .

На Mac или ПК каждый байт имеет свой собственный адрес , число, связанное с ним, которое мы можем использовать для ссылки на этот байт. Байт по адресу 0 является первым байтом в памяти; байт по адресу 1 является вторым и так далее. (Компьютерщики часто начинают считать с 0. Хотите верьте, хотите нет, но нам часто проще начать считать с 0, чем с 1.)

Подождите, как мы относимся к месту в памяти? Используем ли мы имена переменных или адреса? Ответ оба. У вас есть номер ящика Хинмана. Я могу обратиться к вашему почтовому ящику непосредственно по номеру (адресу) или могу использовать ваше имя для ссылки на ящик, предполагая, что у меня есть каталог, который сообщает мне, какой номер ящика связан с вашим именем. Python действует как каталог, который отслеживает соответствие между именами переменных и адресами памяти, где можно найти содержимое переменных.

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

Я только что сказал, что память представляет собой строку из нулей и единиц. Как мы собираемся представить число 42 последовательностью нулей и единиц?

Python использует специальный код, основанный на способе представления чисел по основанию 2 или двоичному коду. Не будем слишком беспокоиться о том, как представлять числа в двоичном виде, а просто скажу вам, что 42 по основанию 2 равно 101010. Вот различные целые числа в двоичном виде:

6	110
18	10010
42	101010
90	1011010
999	1111100111

Первое, на что следует обратить внимание в отношении этих двоичных представлений, — это их длина. Для целого числа 6 требуется всего три бита, а для целого числа 999 — десять бит. В целях безопасности Python выделяет фиксированное количество байтов пространства в памяти для каждой переменной нормального целочисленного типа, которое известно как 9.0045 int в Python. Обычно целое число занимает четыре байта или 32 бита. Целые числа, для двоичного представления которых требуется менее 32 бит, дополняются слева нулями.

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

 00000000
00000001
00000010
00000011
00000100
00000101
...
11111011
11111100
11111101
11111110
11111111 

Похоже, что существует 2 ⁸  = 256 различных узоров. Я мог бы использовать свой один байт для представления 256 уникальных целых чисел, потому что для каждого целого числа потребуется свой битовый шаблон. Если бы у меня было два байта, я мог бы представить 2 ¹⁶ = 65 536 различных целых чисел.

С четырьмя байтами (обычный объем памяти, выделенный для каждой переменной int ) мы можем хранить 2 ³² различных целых чисел. Если крайний левый бит равен 1, число считается отрицательным. Если крайний левый бит равен 0, то число интерпретируется либо как 0 (если все биты равны 0), либо как положительное (если крайний левый бит равен 0, но где-то есть хотя бы одна единица). Таким образом, мы ожидаем, что половина значений int будет отрицательной, одно из них будет равно 0, а остальные будут положительными. Поэтому мы ожидаем наибольших положительных int будет равно 2 ³¹  − 1, или 2 147 483 647, а наибольшее отрицательное целое число будет равно  − 2 ³¹ или -2 147 483 648.

Примечание: Когда вы вводите большие целые числа, будь то часть вашей программы, консольный ввод или ввод где-либо еще, , а не включают запятые. Сделайте , а не , введите 100 000 ; вместо этого введите 100000 . Я включил запятые выше, чтобы вы могли легко увидеть, что два байта дают нам чуть более 65 000 различных чисел, а четыре байта дают нам целые значения с величинами в 2 миллиарда и изменением.

Тип long int

Если вы хотите сохранить число больше 2 147 483 647, Python может сделать это, используя тип данных long int . Вместо того, чтобы выделять фиксированные четыре байта памяти для переменной long int , Python решает, сколько байтов выделить, исходя из фактического размера числа. Большие целые числа потребуют больше памяти, так как самые короткие представления (с наименьшим количеством битов) сначала присваиваются числам, близким к 0. Помимо стоимости памяти, вычисления с длинными целыми числами выполняются намного медленнее, чем вычисления с целыми числами.

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

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

Тип с плавающей запятой подобен экспоненциальному представлению, например, 6,02 × 10 ²³ . Поскольку вы не можете вводить надстрочный индекс в обычном тексте для Python, если требуется показатель степени 10, вы должны написать его так:

Обратите внимание, что мы опускаем 10, но это понятно; 6.02e23 не 6.02 ²³ (6,02 в степени 23), но вместо этого 6,02 × 10 ²³ .

Числа с плавающей запятой хранятся в виде трех частей:

• знак: + или –.
• мантисса, например, 6.02.
• показатель степени, например, 23.

Тип с плавающей запятой (или для краткости «тип с плавающей запятой») используется для чисел, которые состоят из дробных частей или слишком велики для хранения в long int , занимающем разумный объем памяти. Обычно для плавающего типа Python используется восемь байтов. Обратите внимание, что это означает, что существует только 2 ⁶⁴ различные числа с плавающей запятой, которые могут быть представлены. Может показаться, что это много чисел, но помните, что числовая прямая содержит бесконечно много чисел. Таким образом, числа с плавающей запятой допускают лишь ограниченную точность.

Числа с плавающей запятой становятся менее точными по мере удаления от 0

Разница между 0,01 и 0,02 относительно велика (100%), но относительная разница между (6,02e23 + 0,01) и 0,02) не так много, по крайней мере, по сравнению с размером задействованных чисел.

По этой причине числа с плавающей запятой 2 ⁶⁴ неравномерно распределены в строке действительных чисел. Рядом с 0 их расположено больше, чем рядом с числами с большей величиной. Когда вы вводите число с десятичной точкой или создаете его с помощью какой-либо математической операции, компьютер находит число с плавающей запятой, близкое к правильному числу. Мелкие доли, вероятно, будут потеряны в этом процессе округления для очень больших действительных чисел, поскольку ближайшее число с плавающей запятой, которое может представить компьютер, может быть относительно довольно далеко.

Выражения и операторы

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

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

В этом примере операнд слева равен 18, а операнд справа равен 24. Выражение — это оператор и его операнды; мы говорим, что выражение может быть оценено , чтобы дать единственное значение. В нашем примере выражение равно 18 + 24 ; при вычислении значение этого выражения равно 42.

Выражение может быть операндом оператора:

Здесь выражение (3 * 6) является левым операндом оператора + .

Символ * обозначает умножение в Python, чтобы не путать с буквой x . Если Python требуется значение выражения, Python вычисляет это значение. В этом примере значение выражения (3 * 6) необходимо, прежде чем можно будет выполнить сложение, поэтому значение 18 вычисляется первым оператором умножения * . Затем это значение, 18, можно использовать в качестве операнда для оператора сложения.

Арифметические операторы, такие как + , - , * и / (деление), следуют тому же порядку операций, к которому вы привыкли в математике. * и / имеют более высокий приоритет , чем + и - , что означает, что они оцениваются первыми. Операторы с одинаковым приоритетом оцениваются слева направо. Скобки делают порядок операций явным. Если вы сомневаетесь, используйте круглые скобки, чтобы ваш код был максимально удобочитаемым.

Например:

Целочисленное деление

Существует два типа деления, каждое из которых иногда полезно. Целочисленное деление принимает два целых числа и возвращает целое число. Деление с плавающей запятой принимает два числа с плавающей запятой (числа с десятичной запятой) и вычисляет число с плавающей запятой.

Помните такие словесные задачи? На скейт-афоне на озере Мори я катаюсь по овальной ледяной дорожке длиной четыре мили. У меня есть карточка, и за каждый полный круг, который я катаюсь, мне ставят штамп. Если я начну в 12:00 и буду кататься со скоростью 10 миль в час, сколько марок у меня будет в 15:00? В 15:00 я проеду 3 × 10 миль или 30 миль. Разделение 4 на 30 дает 7 кругов и, следовательно, 7 марок с половиной круга (2/4 круга).

В Python версии 2 программа:

 print( (3 * 10) / 4 ) 

дает результат «7»: целочисленное деление. В Python 3 оператор / указывает на деление с плавающей запятой, и тот же код напечатает значение 7,5. Если вы хотите целочисленное деление в Python 3, вы должны использовать оператор `//’.

Использование целочисленного деления вместо деления с плавающей запятой — очень распространенная ошибка в Python 2. Лучшее решение — начать свой код с оператора:

 from __future__ import Division 

Операторы, определенные для целочисленных типов и типов с плавающей запятой:

+ , - , * , / , %

• + : дополнение
• - : вычитание
• * : умножение
• / : деление, целочисленное или с плавающей запятой, как только что обсуждалось
• % : модуль (обычно называемый просто «mod»), который дает «остаток». 9 % 4 равно 1.

Оператор mod в Python необычен тем, что может принимать операнды с плавающей запятой. (Большинство других языков программирования, поддерживающих оператор mod, настаивают на использовании только целочисленных операндов.) Например, 8.0 % 2.5 оценивается как 0.5 , потому что 2.5 входит в число 8 три раза, а 0.5 остается.

Строковый тип

Существует множество различных типов данных для хранения. Целые числа относятся к одному типу; буквы алфавита другие. Тип данных «строка» представляет собой одну или несколько букв алфавита, символов (таких как @ или ~ ) или цифры.

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

Мы называем "Z" строковым литералом , поскольку Python должен интерпретировать его буквально как символ "Z", а не как имя переменной или что-то еще. (В x = 42 число 42 представляет собой целочисленный литерал .)

Кавычки означают, что «привет» — это строка, а не имя переменной. Еще примеры:

Кавычки просто идентифицируют данные как строку; кавычки не являются частью строки.

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

Но print("hello') будет ошибкой.

Конкатенация строк

Знак плюс (" + ") ведет себя по-разному в зависимости от типа данных которые находятся по обе стороны от него. Если с обеих сторон есть целые числа, знак плюса является оператором целочисленного сложения, и он добавляет два целых числа, чтобы получить другое целое число. Если с каждой стороны есть числа с плавающей запятой, они добавлено, чтобы получить еще одно число с плавающей запятой.0033

Что, если с каждой стороны есть веревки? Тогда знак «плюс» — это оператор конкатенации строк . Конкатенация означает «объединение двух строк вместе».

Внутреннее представление строк

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

Какой код использует Python? Python версии 2.7 (версия, которую мы используем для этого класса) использует популярный код под названием American Standard Code for Information Interchange или ASCII . Каждый символ (строка длиной 1) использует восемь бит или один байт. Например, код ASCII для символа A — 01000001, а код ASCII для a — 01100001.

Если вы хотите просмотреть полную таблицу кодов символов ASCII, нажмите здесь. Вам редко нужно знать ASCII-код символа.

Преобразование между типами

Есть несколько специальных функций для преобразования между типами данных: int , float , str полезны для типов данных, которые мы видели до сих пор.

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

Логический тип

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

Стиль кодирования

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

Что он делает? Мы могли бы сказать, запустив его, или мы могли бы добавить комментарии. Или мы могли бы использовать более описательные имена, чем x , y и z .

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

Далее рассмотрим этот код со значащими именами:

Легко понять, что он делает, благодаря выбранным нами именам. Но могло быть и лучше, особенно постоянные значения с плавающей запятой, которые мы там застряли. Предположительно, мы уверены в своей способности вычислить 4,0 * 3,0 / pi (обратите внимание, что я должен убедиться, что по крайней мере одно из 4 и 3 является числом с плавающей запятой, чтобы я не получил целочисленное деление), но если мы сделаем ошибка, будет очень трудно отследить.

Здесь мы заменили число 3,14 на переменную pi и выписали 4,0 / 3,0 вместо предварительного вычисления ее значения.

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

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