float64 python что это

12. Типы данных

Эффективность реализации алгоритмов, зависит от самых разных факторов в числе которых находится и используемый тип данных. В отличии от Python, который предоставляет лишь несколько числовых типов. на самом деле Python предоставляет большое количество не типов а видов чисел, например, в Python можно работать с обыкновенными дробями (модуль fractions) или числа с плавающей точкой произвольной точности (модуль decimal). В данном контексте понятие типа чисел связано с количеством памяти выделяемым под число определенного вида, поэтому, можно сказать, что набор числовых типов в NumPy гораздо больше, так как в Python мы вообще не заботимся о выделении памяти под определенное число. Но при работе с многомерными массивами, в которых могут храниться миллионы и миллиарды чисел, работа с памятью становится важным приоритетом.

В NumPy доступны следующие типы данных:

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

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

Если нужна информация о каком-то конкретном типе чисел с плавающей запятой, то ее можно запросить с помощью функции finfo() :

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

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

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

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

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

12.1. Символьные коды типов данных

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

С одной стороны, с помощью таких символьных кодов определять типы данных вроде бы проще, но с другой стороны они являются менее информативными чем объекты dtype :

Источник

О точности float в Python

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

Здравый смысл подсказывает нам, что здесь что-то не так, должно же равняться! Новичков это вообще может вбить в ступор. Программисты поопытнее могут объяснить это ошибками округления float-чисел. Давайте же разберемся, что на самом деле там происходит.

Экспоненциальное представление чисел

Стандарт IEEE-754 регулирует, как должны представляться вещественные числа в железе (процессорах, сопроцессорах и так далее) и программном обеспечении. Так много вариантов представлений, но на практике почти везде сейчас используются числа с плавающей точкой одинарной или двойной точности, причем оба варианта с основанием 2, это важно.

Плавающая точка

Почему точка плавающая? Потому что числе представлены внутри компьютера экспоненциальном формате:

Число = ±мантисса * основание экпонента

Меняя экспоненту можно двигать положение точки в любую сторону. Например, если основание было бы 10, то числа 1,2345678; 1 234 567,8; 0,000012345678; 12 345 678 000 000 000 отличались бы только экспонентой.

float в Python

float – встроенные тип в Python (CPython) и представляет собой число с плавающей точкой двойной точности, независимо от системы и версии.

float в Python – это double из C, C++, C# или Java и имеет 64 бита (8 байт) для хранения данных о числе.

Примечание: сторонними библиотеками можно получить и другие типы, а еще есть Decimal.

В эти 64 бита упакованы как 11 бит на экспоненту и 52 бита на мантиссу (+ 1 бит на знак, итого 53). Вот так:

Здесь про 0.6, но смысл тот же.

Источник ошибок

Откуда же берутся ошибки?

Дело в том, что числа 0.1 – нет! Действительно, нет способа представить это немудреное число в формате с плавающей точкой с основанием 2!

0.1 – это просто текст, для которого Python должен подобрать максимально близкое представление в памяти компьютера. Можно найти число поменьше или побольше, но точно 0.1 – не получится. Все дело в основании 2 – именно двойка фигурирует под степенью. Надо подобрать такие J и N, чтобы получить число максимально близкое к 0.1:

При этом в J должно быть ровно 53 бита. Наиболее подходящие N для такого случая равняется 56.

Оно чуть больше, чем реальное 0.1. Если бы мы не прибавили единицу, то получилось бы число чуть меньшее, чем 0.1, но никакое сочетание J и N не даст нам ровно 0.1 ни в едином случае!

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

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

Она мала, но она есть! Именно поэтому никогда не советуют точно сравнивать числа типа float, даже если для вас они равны, их представления могут отличаться, если числа получены разным путем. Могут отличаться, а могут и совпадать! Так что это может сыграть злую шутку.

Там есть функция, которая делает более аккуратное сложение IEEE-754 чисел, но она тоже работает не идеально. На примере из документации – отлично и проваливается на нашем пресловутом триплете из 0.1:

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

Специально для канала @pyway. Подписывайтесь на мой канал в Телеграм @pyway 👈

Источник

NumPy в Python. Часть 1

Предисловие переводчика

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

Введение

Установка

Если у вас есть Python(x, y) (Примечание переводчика: Python(x, y), это дистрибутив свободного научного и инженерного программного обеспечения для численных расчётов, анализа и визуализации данных на основе языка программирования Python и большого числа модулей (библиотек)) на платформе Windows, то вы готовы начинать. Если же нет, то после установки python, вам нужно установить пакеты самостоятельно, сначала NumPy потом SciPy. Установка доступна здесь. Следуйте установке на странице, там всё предельно понятно.

Немного дополнительной информации

Сообщество NumPy и SciPy поддерживает онлайн руководство, включающие гайды и туториалы, тут: docs.scipy.org/doc.

Импорт модуля numpy

Есть несколько путей импорта. Стандартный метод это — использовать простое выражение:

Тем не менее, для большого количества вызовов функций numpy, становится утомительно писать numpy.X снова и снова. Вместо этого намного легче сделать это так:

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

Однако, этот вариант не приветствуется в программировании на python, так как убирает некоторые полезные структуры, которые модуль предоставляет. До конца этого туториала мы будем использовать второй вариант импорта (import numpy as np).

Массивы

Главной особенностью numpy является объект array. Массивы схожи со списками в python, исключая тот факт, что элементы массива должны иметь одинаковый тип данных, как float и int. С массивами можно проводить числовые операции с большим объемом информации в разы быстрее и, главное, намного эффективнее чем со списками.

Создание массива из списка:

Здесь функция array принимает два аргумента: список для конвертации в массив и тип для каждого элемента. Ко всем элементам можно получить доступ и манипулировать ими так же, как вы бы это делали с обычными списками:

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

Array slicing работает с многомерными массивами аналогично, как и с одномерными, применяя каждый срез, как фильтр для установленного измерения. Используйте «:» в измерении для указывания использования всех элементов этого измерения:

Метод shape возвращает количество строк и столбцов в матрице:

Метод dtype возвращает тип переменных, хранящихся в массиве:

Тут float64, это числовой тип данных в numpy, который используется для хранения вещественных чисел двойной точности. Так же как float в Python.

Метод len возвращает длину первого измерения (оси):

Метод in используется для проверки на наличие элемента в массиве:

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

Обратите внимание, метод reshape создает новый массив, а не модифицирует оригинальный.

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

Списки можно тоже создавать с массивов:

Можно также переконвертировать массив в бинарную строку (то есть, не human-readable форму). Используйте метод tostring для этого. Метод fromstring работает в для обратного преобразования. Эти операции иногда полезны для сохранения большого количества данных в файлах, которые могут быть считаны в будущем.

Заполнение массива одинаковым значением.

Транспонирование массивов также возможно, при этом создается новый массив:

Многомерный массив можно переконвертировать в одномерный при помощи метода flatten:

Два или больше массивов можно сконкатенировать при помощи метода concatenate:

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

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

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

На этом у нас конец первой части перевода. Спасибо за внимание.

Источник

Числа, строки и другие типы данных в Python

Из этого руководства вы узнаете о базовых встроенных типах данных Python: числовых, строковых и логических (булевых).

Целые числа

В Python 3 фактически нет предела длины целочисленного значения. Конечно, оно ограничено объемом доступной в системе памяти (как и любые другие типы данных), но в остальном — может быть таким длинным, как нужно:

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

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

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

Базовый тип целого числа в Python, вне зависимости от используемого основания, называется int :

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

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

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

Тип float в Python означает число с плавающей точкой. Значения float определяются с десятичной точкой. По желанию можно добавить символ e или E после целого числа, чтобы обозначить, что это экспоненциальная запись.

Подробнее: представление float

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

Почти все платформы представляют числа с плавающей точкой Python как 64-битные значения двойной точности в соответствии со стандартом IEEE 754. В таком случае максимальное значение числа с плавающей точкой — это приблизительно 1.8 х 10308. Числа больше Python будет помечать в виде строки inf :

Числа с плавающей точкой представлены в виде двоичных (с основанием 2) фракций. Большая часть десятичных фракций не может быть представлена в виде двоичных, поэтому в большинстве случаев внутреннее представление — это приближенное к реальному значение. На практике отличия представленного и реального значения настолько малы, что это не должно создавать проблем.

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

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

Строки

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

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

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

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

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

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

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

Управляющие последовательности (исключенные последовательности)

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

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

Посмотрим, как это работает.

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

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

Обратный слэш перед одинарной кавычкой «освобождает» ее от специального значения и заставляет Python воспринимать буквальное значение:

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

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

Обычно символ новой строки ( newline ) заменяет enter. Поэтому он в середине строки заставит Python думать, что она неполная:

Чтобы разбить строку на несколько строк кода, добавьте обратный слэш перед переходом на новую строку и newline будет игнорироваться:

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

Добавление специального значения символам

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

В Python (и большинстве других распространенных языков) символ табуляции определяется управляющей последовательностью \t :

Она заставляет символ \t терять свое привычное значение и интерпретируется как символ табуляции.

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

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

«Сырые» строки

Строки в тройных кавычка

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

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

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

Булев тип, Булев контекст и «истинность»

В Python 3 три типа Булевых данных. Объекты булевого типа принимают одно из двух значений, True или False :

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

«Истинность» объекта типа Boolean самоочевидна: объекты равные True являются истинными, а те, что равны False — ложными. Но не-Булевы объекты также могут быть оценены в Булевом контексте.

Источник

Data types¶

Array types and conversions between types¶

NumPy supports a much greater variety of numerical types than Python does. This section shows which are available, and how to modify an array’s data-type.

The primitive types supported are tied closely to those in C:

Boolean (True or False) stored as a byte

unsigned long long

Half precision float: sign bit, 5 bits exponent, 10 bits mantissa

Platform-defined single precision float: typically sign bit, 8 bits exponent, 23 bits mantissa

Platform-defined double precision float: typically sign bit, 11 bits exponent, 52 bits mantissa.

Platform-defined extended-precision float

Complex number, represented by two single-precision floats (real and imaginary components)

Complex number, represented by two double-precision floats (real and imaginary components).

long double complex

Complex number, represented by two extended-precision floats (real and imaginary components).

Since many of these have platform-dependent definitions, a set of fixed-size aliases are provided (See Sized aliases ).

NumPy numerical types are instances of dtype (data-type) objects, each having unique characteristics. Once you have imported NumPy using

Data-types can be used as functions to convert python numbers to array scalars (see the array scalar section for an explanation), python sequences of numbers to arrays of that type, or as arguments to the dtype keyword that many numpy functions or methods accept. Some examples:

Array types can also be referred to by character codes, mostly to retain backward compatibility with older packages such as Numeric. Some documentation may still refer to these, for example:

We recommend using dtype objects instead.

To determine the type of an array, look at the dtype attribute:

dtype objects also contain information about the type, such as its bit-width and its byte-order. The data type can also be used indirectly to query properties of the type, such as whether it is an integer:

Array Scalars¶

The primary advantage of using array scalars is that they preserve the array type (Python may not have a matching scalar type available, e.g. int16 ). Therefore, the use of array scalars ensures identical behaviour between arrays and scalars, irrespective of whether the value is inside an array or not. NumPy scalars also have many of the same methods arrays do.

Overflow Errors¶

The fixed size of NumPy numeric types may cause overflow errors when a value requires more memory than available in the data type. For example, numpy.power evaluates 100 ** 8 correctly for 64-bit integers, but gives 1874919424 (incorrect) for a 32-bit integer.

NumPy provides numpy.iinfo and numpy.finfo to verify the minimum or maximum values of NumPy integer and floating point values respectively

If 64-bit integers are still too small the result may be cast to a floating point number. Floating point numbers offer a larger, but inexact, range of possible values.

Extended Precision¶

NumPy does not provide a dtype with more precision than C’s long double \; in particular, the 128-bit IEEE quad precision data type (FORTRAN’s REAL*16 \) is not available.

© Copyright 2008-2021, The NumPy community.
Last updated on Jun 22, 2021.
Created using Sphinx 4.0.1.

Источник