Преобразование строк в числа и чисел в строки в Python

Вступление

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

Примечание . Для простоты запуска и демонстрации этих примеров мы будем использовать интерпретатор Python.

Струны

Строковые литералы в Python объявляются заключением символа в двойные (") или одинарные кавычки (') знаки. Строки в Python на самом деле представляют собой просто массивы с Unicode для каждого символа в качестве элемента в массиве, что позволяет использовать индексы для доступа один символ из строки.

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

 >>> stringFirst = "Hello World!" 
 >>> stringSecond = 'Again!' 
 >>> stringFirst[3] 
 'l' 
 >>> stringSecond[3] 
 'i'

Числовые

Числовое значение в Python может быть integer , float или complex .

Целые числа могут быть положительными или отрицательными целыми числами. Начиная с Python 3, целые числа не ограничены и могут содержать практически любое число. До Python 3 верхняя граница была 2 ^31^ -1 для 32-разрядных сред выполнения и ^263^ -1 для 64-разрядных сред выполнения.

У чисел с плавающей запятой также неограниченная длина, но число с плавающей запятой должно содержать десятичную точку.

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

 >>> integerFirst = 23 
 >>> floatFirst = 23.23 
 >>> complextFirst = 1 + 23j

Преобразование строк в числа

Использование функции int ()

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

 >>> x = "23" 
 >>> y = "20" 
 >>> z = int(x) - int(y) 
 >>> z 
 3

Это работает, как ожидалось, когда вы передаете строковое представление целого числа в int() , но вы столкнетесь с проблемами, если переданная вами строка не содержит целочисленного значения. Если в вашей строке есть какие-либо нечисловые символы, тогда int() вызовет исключение:

 >>> x = "23a" 
 >>> z = int(x) 
 Traceback (most recent call last): 
 File "<stdin>", line 1, in <module> 
 ValueError: invalid literal for int() with base 10: '23a'

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

 >>> x = "23.4" 
 >>> z = int(x) 
 Traceback (most recent call last): 
 File "<stdin>", line 1, in <module> 
 ValueError: invalid literal for int() with base 10: '23.4'

int() функция имеет другую полезную функцию , чем просто преобразование строк в целые числа, он также позволяет преобразовывать числа из любой базы к основанию 10 целого числа. Например, мы можем преобразовать следующую двоичную строку в целое число с основанием 10, используя base параметр:

 >>> int('1101100', base=2) 
 108

То же самое можно сделать для любой другой базы, например, шестнадцатеричной (база 16):

 >>> int('6C', base=16) 
 108

Использование функции float ()

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

 >>> x = "23.23" 
 >>> y = "23.00" 
 >>> z = float(x) - float(y) 
 >>> z 
 0.23000000000000043

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

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

 >>> x = "23" 
 >>> y = "20" 
 >>> z = float(x) - float(y) 
 >>> z 
 3.0

В отличие от int() , float() не вызывает исключения, когда получает числовое значение, отличное от float.

Однако он вызовет исключение, если ему будет передано нечисловое значение:

 >>> x = "23a" 
 >>> z = float(x) 
 Traceback (most recent call last): 
 File "<stdin>", line 1, in <module> 
 ValueError: could not convert string to float: '23a'

В то время как float() не имеет возможности конвертировать не-базу 10 номеров , как int() делает, у него есть способность к номерам преобразовывают , представленные в научной нотации (он же е-обозначение):

 >>> float('23e-5') 
 0.00023 
 >>> float('23e2') 
 2300.0

Использование функции complex ()

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

 >>> x = "5+3j" 
 >>> y = "3+1j" 
 >>> z = complex(x) + complex(y) 
 >>> z 
 (8+4j)

Наличие лишних пробелов между + или - приведет к возникновению исключения:

 >>> z = complex("5+ 3j") 
 Traceback (most recent call last): 
 File "<stdin>", line 1, in <module> 
 ValueError: complex() arg is a malformed string

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

 >>> complex("1") 
 (1+0j) 
 >>> complex("1.2") 
 (1.2+0j)

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

Преобразование чисел в строки

Использование функции str ()

str() можно использовать для преобразования любого числового типа в строку.

Функция str() доступна из Python 3.0+, поскольку строки в Python 3.0+ по умолчанию являются Unicode. Однако это неверно для версий Python ниже 3.0 - в которых для достижения той же цели используется функция unicode()

 >>> str(23) # Integer to String 
 '23' 
 >>> str(23.3) # Float to String 
 '23.3' 
 >>> str(5+4j) # Complex to String 
 '(5+4j)'

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

Использование функции format ()

Другой способ преобразования чисел в строки - использование функции format() , которая позволяет вам устанавливать заполнители внутри строки, а затем преобразовывать другой тип данных в строку и заполнять заполнители.

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

Вот пример:

 >>> "My age is {}".format(21) 
 'My age is 21'

На аргументы в функции .format() также можно ссылаться индивидуально, используя их позиции или имена переменных:

 >>> "You get {product} when you multiply {1} with {0}".format(5.5, 3, product=16.5) 
 'You get 16.5 when you multiply 3 with 5.5'

Обратите внимание, что под капотом .format() просто использует str() для преобразования аргументов в строки. По сути, это тот же способ преобразования чисел в строки, что и в предыдущем разделе, но .format() действует как удобная функция для форматирования строки.

Заключение

Python позволяет взаимозаменяемо преобразовывать строки, целые числа и числа с плавающей запятой несколькими различными способами. Самый простой способ сделать это - использовать базовые функции str() , int() и float() . Помимо этого, есть еще несколько способов, например, функция format() Просто имейте в виду, что функции int() , float() и complex() имеют свои ограничения и могут вызывать исключения, если входная строка отформатирована не так, как они ожидали.