Как преобразовать число в строку в Python
Преобразование чисел в строки в Python
Чтобы конвертировать число в строку, используйте встроенную функцию str()
. Эта функция в качестве входящих данных принимает число (или другой тип данных), а в результате выдает строку.
Примеры
Вот один пример:
>>> str(123) '123'
Если число является значением переменной, конвертировать его можно следующим образом:
>>> number = 999 >>> number_as_string = str(number) >>> number_as_string '999'
Конкатенация строк и чисел в Python
Иногда возникает необходимость сконструировать строку, содержащую число из другой переменной. Вот пример, как это делается:
>>> week = 33 >>> greeting = "it is week " + str(week) >>> greeting 'it is week 33'
Избегаем преобразования типов данных
Когда разработчикам нужно объединить число и строку, они обычно применяют функцию str()
непосредственно перед выводом данных на экран. Например:
>>> name = "Bob" >>> age = 33 >>> print(name + " is " + str(age) + " years old") Bob is 33 years old
Но гораздо более чистый способ — применять к строкам метод .format()
:
>>> print("{name} is {age} years old".format(name=name, age=age)) Bob is 33 years old
А еще лучше — использовать f-строки (Python 3):
>>> print(f"{name} is {age} years old") Bob is 33 years old
Преобразование строки в число в Python. Особенности преобразования числа в строку
Иногда нам нужно выполнить преобразование строки в целое число либо в число с плавающей точкой. Потребность в этом возникает для осуществления ряда операций. Как это сделать в Python, мы сейчас и поговорим.
Чтобы осуществить преобразование строки в целое число либо число с плавающей точкой, в Python используют функции
str_a = ’50’ b = 10 c = str_a + b print (c)
Преобразование строки в целое число с помощью int() в Python
Давайте посмотрим на следующий участок кода:
str_a = '50' b = 10 c = int(str_a) + b print ("The value of c = ",c)
С его помощью мы выведем значение переменной «c», которое будет представлять собой сумму переменных «str_a» и «b».
Преобразуем десятичную строку в число с плавающей точкой в Python
Для преобразования строки в число с плавающей точкой мы можем использовать float:
#Преобразование string во float str_a = '50.85' b = 10.33 c = float(str_a) + b print ("The value of c = ",c)
Однако учтите, что если вы захотите задействовать тут функцию int(), это приведёт к ошибке.
Преобразуем список строковых чисел в список целых чисел в Python
Бывает, что в Python необходимо выполнить преобразование строки из чисел, содержащихся в списке. В таких случаях нам поможет генератор списков. Таким образом создаётся новый список, где можно использовать функцию int()в каждой итерации:
#Преобразование string в int в списке str_lst = ['1', '2', '3'] int_lst = [int(x) for x in str_lst] print (int_lst)
Мы выведем новый список, который будет состоять из целых чисел, полученных из строк.
Преобразуем список строк в список чисел с плавающей точкой в Python
Аналогично можно применять float вместо int для выполнения преобразования списка, включающего в себя строки из целых чисел:
#Преобразование string во float в списке str_lst = ['10.505', '2.3', '3.99'] float_lst = [float(x) for x in str_lst] print (float_lst)
Преобразование строки с запятыми в число в Python
Что делать, если у нас строка наподобие «1,000,000»? Если мы попробуем выполнить её преобразование с помощью функций int() либо float(), мы получим ошибку.
Одно из решений — применение import locale:
locale.setlocale(locale.LC_ALL, ‘en_US.UTF-8’ )
Приём работает, но он не идеален. Другое решение — заменить запятые на пустые строки, а потом применить уже известную нам функцию int:
str_a = '5,123,000' int_b = int(str_a.replace(',','')) print ("The integer value",int_b)
Результат — целое значение. Это же решение мы можем использовать и для преобразования строки в число с плавающей точкой в Python.
Преобразование строки в число при расчёте високосного года в Python
Как известно, пользовательский ввод в «Пайтоне» воспринимается как строка. К примеру, в следующем коде программа попросит пользователя ввести год, а после ввода значений программа сообщит, является ли этот год високосным. При этом введённое значение сначала будет преобразовано в целое число, а потом будет задействована формула расчёта високосного года:
#Расчёт високосного года try: Y = int(input("Enter a Year? ")) exceptValueError: print ("You may only enter digits in '2000' format!") else: leap_or_not = Y%4 == 0 ifleap_or_not: print ("Leap year") else: print ("Not a leap year")
Таким образом происходит преобразование вводимой строки в целое число, а потом это число применяется для расчёта.
Как преобразовать целое число в строку в Python?
При выполнении преобразования целых чисел в строки используется функция str(). Она принимает объект, который может иметь тип int, float, double и так далее.
Давайте посмотрим на пример преобразования переменной int в строку, которая потом применяется как строка для конкатенации:
#Преобразование int в string a_string = "str function for int to string" a_num = 456 print (a_string + str(a_num))
Результат будет следующим:
str function for int to string456
Кстати, если бы целочисленная переменная была нами использована без str(), результатом стала бы ошибка TypeError.
Преобразование числа в строку в Python?
Я хочу преобразовать целое число в строку в Python. Я пишу его напрасно:—4—>
d = 15
d.str()
когда я пытаюсь преобразовать его в строку, он показывает ошибку, как int
не имеет никакого атрибута с именем str
.
1042
автор: Aran-Fey
10 ответов
>>> str(10)
'10'
>>> int('10')
10
ссылки на документацию:
проблема, кажется, исходит из этой строки:d.str()
.
преобразование в строку выполняется с помощью builtin str()
функция, которая в основном называет __str__()
метод его параметра.
кроме того, не должно быть необходимости звонить
. Попробуйте использовать **
оператора.
1640
автор: Bastien Léonard
попробуйте это:
str(i)
84
автор: Lasse Vågsæther Karlsen
в Python нет typecast и нет принуждения типа. Вы должны преобразовать свою переменную явным образом.
для преобразования объекта в строку вы используете
44
автор: Andrea Ambu
a = 2
можно использовать str(a)
, который дает вам объект строку int(2)
.
20
автор: Tarun Gupta
для управления нецелыми входами:
number = raw_input()
try:
value = int(number)
except ValueError:
value = 0
хорошо, если я возьму ваш последний код и перепишу немного, чтобы заставить его работать с Python:
t=raw_input()
c=[]
for j in range(0,int(t)):
n=raw_input()
a=[]
a,b= (int(i) for i in n.split(' '))
d=pow(a,b)
d2=str(d)
c.append(d2[0])
for j in c:
print j
это дает мне что-то вроде:
>>> 2
>>> 8 2
>>> 2 3
6
8
который является первым символом результата строки pow(a,b)
.
Что мы пытаемся здесь сделать?
>>> i = 5
>>> print "Hello, world the number is " + i
TypeError: must be str, not int
>>> s = str(i)
>>> print "Hello, world the number is " + s
Hello, world the number is 5
12
автор: maxaposteriori
самый приличный способ, на мой взгляд,».
i = 32 --> `i` == '32'
можно использовать %s
или .format
>>> "%s" % 10
'10'
>>>
(или)
>>> '{}'.format(10)
'10'
>>>
в Python => 3.6 вы можете использовать f
форматирование:
>>> int_value = 10
>>> f'{int_value}'
'10'
>>>
для тех, кто хочет преобразовать int в строку в определенных цифрах, рекомендуется следующий метод.
month = "{0:04d}".format(localtime[1])
для получения дополнительной информации вы можете обратиться к вопросу переполнения стека отобразить число с ведущими нулями.
Преобразование строк в целые числа Python
Для преобразования значений из одного типа в другой существует несколько функций. В следующих строках показана та из них, которая приводит аргумент к целочисленному типу:
year = input(«Год вашего рождения:\n») year = int(year)
year = input(«Год вашего рождения:\n») year = int(year) |
Первая из этих двух строк принимает пользовательский ввод (строку) и делает его значением переменной year. Во второй строке выполняется преобразование: функция int() принимает строку, на которую ссылается year, и возвращает ее преобразованной в целое число. Это новое значение присваивается той же переменной year.
В следующих пяти строках другие издержки принимаются из пользовательского ввода и преобразуются в числа:
countries = int(input(«Сколько государств?\n»)) players = int(input(«Сколько игроков участвуют?\n»)) goals = int(input(«Сколько голов забил зенит?\n»)) fingers = int(input(«Сколько пальцев на одной руке?\n»)) books = int(input(«Сколько книг желаете купить?\n»))
countries = int(input(«Сколько государств?\n»)) players = int(input(«Сколько игроков участвуют?\n»)) goals = int(input(«Сколько голов забил зенит?\n»)) fingers = int(input(«Сколько пальцев на одной руке?\n»)) books = int(input(«Сколько книг желаете купить?\n»)) |
Заметьте, что каждое присвоение выполняется в одну строку кода. А все потому, что вызовы функций input() и int() — вложенные. Когда говорят о вложении вызовов функций, имеют в виду, что один находится внутри другого. Это удобно, если значение, возвращаемое «внутренней» функцией, может выступать как арrумент для «внешней» функции. Здесь input() возвращает строковое значение, которое int() успешно преобразует в число.
В конструкции, присваивающей значение переменной goals, функция input() сначала спрашивает у пользователя, сколько голов забил зенит. Пользователь что-то отвечает, это строковое значение input() возвратит, после чего программа применит функцию int() к этой строке как аргументу. В свою очередь, int() возвратит целое число. Это число и становится значением переменной goals. Точно так же присвоение выполняется и в следующих выражениях.
Есть и другие функции конвертации значений между типами. Некоторые из них перечислены ниже.
Функция | Описание | Пример | Результат |
float(x) | Преобразует значение х в десятичную дробь | float(5) | 5.0 |
int(x) | Преобразует значение х в целое число | int(«30») | 30 |
str(x) | Преобразует значение х в строку | str(50.5) | ‘50.5’ |
Python 3 — преобразование типов номеров
Вступление
В Python типы данных используются для классификации одного конкретного типа данных, определяя значения, которые вы можете назначить типу и операциям, которые вы можете выполнить на нем. При программировании иногда нам нужно преобразовать значения между типами, чтобы манипулировать значениями по-другому. Например, нам может понадобиться конкатенация числовых значений со строками или представление десятичных знаков в числах, которые были инициализированы как целочисленные значения.
Этот учебник поможет вам преобразовать числа, строки, кортежи и списки, а также предоставить примеры, которые помогут вам ознакомиться с различными вариантами использования.
Преобразование типов номеров
В Python существует два типа данных данных : целые числа и числа с плавающей запятой или поплавки. Иногда вы работаете над чьим-то кодом и вам нужно преобразовать целое число в float или наоборот, или вы можете обнаружить, что вы используете целое число, когда то, что вам действительно нужно, — это float. Python имеет встроенные методы, позволяющие легко преобразовывать целые числа в float и float в целые числа.
Преобразование целых чисел в поплавки
Метод Python float()
будет преобразовывать целые числа в float. Чтобы использовать эту функцию, добавьте целое число в круглые скобки:
float(57)
В этом случае 57
будет преобразовано в 57.0
.
Вы также можете использовать это с переменной. Объявим f
как равный 57
, а затем распечатаем новый float:
f = 57 print(float(f))
Output
57.0
Используя эту float()
функцию, мы можем преобразовать целые числа в float.
Преобразование плавающих чисел в целые числа
Python также имеет встроенную функцию для преобразования поплавков целых чисел: int()
.
int()
Функция работает аналогично float()
функции: вы можете добавить число с плавающей точкой внутри скобок , чтобы преобразовать его в целое число:
int(390.8)
В этом случае 390.8
будет преобразовано в 390
.
Вы также можете использовать это с переменными. Объявим b
как равные 125.0
и c
равные 390.8
, а затем распечатаем новые поплавки:
b = 125.0 c = 390.8 print(int(b)) print(int(c))
Output
125
390
При преобразовании float в целые числа с int()
функцией Python отключает десятичные и оставшиеся числа float для создания целого числа. Несмотря на то, что мы, возможно, захотим округлить 390,8 до 391, Python не будет делать этого через int()
функцию.
Цифры, конвертированные под деление
В Python 3 соответствующие коэффициенты преобразуются из целых чисел в float при выполнении разделения, хотя они не находятся в Python 2 . То есть, когда вы разделите 5 на 2, в Python 3 вы получите поплавок для ответа (2.5):
a = 5 / 2 print(a)
Output
2.5
В Python 2, так как вы имели дело с двумя целыми числами, вы получите целое число обратно в качестве ответа, вместо этого: 5 / 2 = 2
. Прочтите « Python 2 vs Python 3: Практические соображения » для получения дополнительной информации о различиях между Python 2 и Python 3.
Преобразование строк
Строка представляет собой последовательность из одного или нескольких символов (буквы, цифры, символы). Строки — это общая форма данных в компьютерных программах, и нам может потребоваться довольно часто преобразовывать строки в числа или числа в строки, особенно когда мы принимаем данные, созданные пользователем.
Преобразование чисел в строки
Мы можем преобразовать числа в строки с помощью str()
метода. Мы передадим либо число, либо переменную в круглые скобки метода, а затем числовое значение будет преобразовано в строковое значение.
Давайте сначала рассмотрим преобразование целых чисел. Чтобы преобразовать целое число 12
в строковое значение, вы можете перейти 12
к str()
методу:
str(12)
При запуске str(12)
в интерактивной оболочке Python с python
командой в окне терминала вы получите следующий вывод:
Output
'12'
Котировки вокруг числа 12 означают, что число больше не является целым числом, а теперь является строковым значением.
С переменными мы можем начать понимать, насколько практично это можно преобразовать целые числа в строки. Предположим, мы хотим отслеживать ежедневный прогресс программирования пользователя и вводить количество строк кода, которые они пишут за раз. Мы хотели бы показать эту обратную связь пользователю и будем печатать строки и целочисленные значения в одно и то же время:
user = "Sammy"
lines = 50
print("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
Когда мы запускаем этот код, мы получаем следующую ошибку:
Output
TypeError: Can't convert 'int' object to str implicitly
Мы не можем конкатенировать строки и целые числа в Python, поэтому нам придется преобразовать переменную lines
в строковое значение:
user = "Sammy"
lines = 50
print("Congratulations, " + user + "! You just wrote " + str(lines) + " lines of code.")
Теперь, когда мы запускаем код, мы получаем следующий результат, который поздравляет нашего пользователя с их прогрессом:
Output
Congratulations, Sammy! You just wrote 50 lines of code.
Если мы хотим преобразовать float в строку, а не в целое число в строку, мы выполняем те же шаги и формат. Когда мы передаем float в str()
метод, будет возвращено строковое значение float. Мы можем использовать либо значение float, либо значение переменной:
print(str(421.034)) f = 5524.53 print(str(f))
Output
421.034
5524.53
Мы можем проверить, чтобы убедиться, что это правильно, объединив строку:
f = 5524.53 print("Sammy has " + str(f) + " points.")
Output
Sammy has 5524.53 points.
Мы можем быть уверены, что наш float был правильно преобразован в строку, потому что конкатенация выполнялась без ошибок.
Преобразование строк в числа
Строки могут быть преобразованы в числа, используя int()
и float()
методы.
Если ваша строка не имеет десятичных знаков, вы, скорее всего, захотите преобразовать ее в целое число с помощью int()
метода.
Давайте используем пример пользователя Sammy, отслеживающего строки кода, написанные каждый день. Мы можем манипулировать этими значениями математикой, чтобы предоставить пользователям более интересные отзывы, но эти значения в настоящее время хранятся в строках:
lines_yesterday = "50" lines_today = "108" lines_more = lines_today - lines_yesterday print(lines_more)
Output
TypeError: unsupported operand type(s) for -: 'str' and 'str'
Поскольку два числовых значения были сохранены в строках, мы получили сообщение об ошибке. Операнд -
для вычитания не является допустимым операндом для двух строковых значений.
Давайте изменим код, чтобы включить int()
метод, который преобразует строки в целые числа, и позволит нам выполнять математику со значениями, которые были первоначально строками.
lines_yesterday = "50" lines_today = "108" lines_more = int(lines_today) - int(lines_yesterday) print(lines_more)
Output
58
Эта переменная lines_more
автоматически является целым числом, и в этом примере она равна числовому значению 58.
Мы также можем преобразовать числа в приведенном выше примере в значения float, используя float()
метод вместо int()
метода. Вместо получения вывода 58
мы получим вывод 58.0
float.
Пользователь Sammy получает точки в десятичных значениях
total_points = "5524.53" new_points = "45.30" new_total_points = total_points + new_points print(new_total_points)
Output
5524.5345.30
В этом случае использование +
операнда с двумя строками является действительной операцией, но она объединяет две строки, а не объединяет два числовых значения. Таким образом, наш вывод выглядит необычным, поскольку он просто помещает два значения рядом друг с другом.
Мы захотим преобразовать эти строки в float до выполнения любой математики с помощью float()
метода:
total_points = "5524.53" new_points = "45.30" new_total_points = float(total_points) + float(new_points) print(new_total_points)
Output
5569.83
Теперь, когда мы превратили две строки в поплавках, мы получим ожидаемый результат , который добавляет 45.30
к 5524.53
.
Если мы попытаемся преобразовать строковое значение с десятичными знаками в целое число, мы получим ошибку:
f = "54.23" print(int(f))
Output
ValueError: invalid literal for int() with base 10: '54.23'
Если мы передадим десятичное значение в строке int()
методу, мы получим ошибку, потому что она не будет конвертировать в целое число.
Преобразование строк в числа позволяет нам быстро изменять тип данных, с которыми мы работаем, чтобы мы могли выполнять операции с числовыми значениями, которые были первоначально выбраны как строки.
Преобразование в кортежи и списки
Вы можете использовать методы list()
и tuple()
преобразовывать значения, переданные им в список и тип данных кортежа соответственно. В Python:
- список является изменяемой упорядоченной последовательностью элементов , которые содержатся в квадратных скобках
[ ]
. - кортеж является непреложной упорядоченной последовательностью элементов , содержащихся в скобках
( )
.
Преобразование в кортежи
Начнем с преобразования списка в кортеж. Преобразование списка в кортеж, поскольку он является неизменным типом данных, может обеспечить существенную оптимизацию программ, которые мы создаем. Когда мы используем метод, tuple()
он вернет версию кортежа переданного ей значения.
print(tuple(['pull request', 'open source', 'repository', 'branch']))
Output
('pull request', 'open source', 'repository', 'branch')
Мы видим, что на выходе печатается кортеж, поскольку элементы теперь содержатся в скобках, а не в квадратных скобках.
Давайте используем tuple()
переменную, представляющую список:
sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp'] print(tuple(sea_creatures))
Output
('shark', 'cuttlefish', 'squid', 'mantis shrimp')
Опять же, мы видим, что значение списка изменяется на значение кортежа, указанное скобками. Мы можем преобразовать любой итерируемый тип в кортеж, включая строки:
print(tuple('Sammy'))
Output
('S', 'a', 'm', 'm', 'y')
Поскольку мы можем выполнять итерацию по строкам, мы можем преобразовать их в кортежи с помощью tuple()
метода. Однако, если типы данных, которые не являются итерируемыми, как целые числа и поплавки, мы получим ошибку типа:
print(tuple(5000))
Output
TypeError: 'int' object is not iterable
Хотя можно преобразовать целое число в строку и затем преобразовать в кортеж, как и в tuple(str(5000))
, лучше всего выбрать читаемый код для сложных преобразований.
Преобразование в списки
Преобразование значений, особенно кортежей, в списки может быть полезно, когда вам нужно иметь изменяемую версию этого значения.
Мы будем использовать list()
метод для преобразования следующего кортежа в список. Поскольку синтаксис для создания списка использует круглые скобки, обязательно укажите круглые скобки list()
метода, и в этом случае также print()
метод:
print(list(('blue coral', 'staghorn coral', 'pillar coral')))
Output
['blue coral', 'staghorn coral', 'pillar coral']
Квадратные скобки сигнализируют, что список был возвращен из исходного значения кортежа, которое было передано list()
методом.
Чтобы сделать код более читаемым, мы можем удалить одну из пар круглых скобок, используя переменную:
coral = ('blue coral', 'staghorn coral', 'pillar coral')
list(coral)
Если мы напечатаем, list(coral)
мы получим тот же результат, что и выше.
Так же, как кортежи, строки могут быть преобразованы в списки:
print(list('shark'))
Output
['s', 'h', 'a', 'r', 'k']
Здесь строка 'shark'
была преобразована в список, предоставляя изменяемую версию исходного значения.
Заключение
В этом учебнике Python показано, как преобразовать несколько важных типов родных данных в другие типы данных, в первую очередь, с помощью встроенных методов. Возможность конвертировать типы данных в Python обеспечивает дополнительную гибкость при написании ваших программ.
5 примеров преобразования строки в целое число или число с плавающей точкой в Python
Иногда требуется преобразовать строку в целое число или в число с плавающей точкой для осуществления определённых операций в Python.
Если вы попробуете выполнить то или иное действие со строкой в виде чисел, то получите ошибку.
Этот код приведёт к ошибке:
str_a = ’50’ b = 10 c = str_a + b print (c)
В Python можно использовать функции int и float для преобразования строки в целое число или число с плавающей точкой до осуществления каких-либо операций.
Рассмотрим следующий код:
str_a = '50' b = 10 c = int(str_a) + b print ("The value of c = ",c)
В результате его работы выведется значение переменной c, представляющее собой сумму переменных str_a и b.
Можно использовать класс float для преобразования строки в число с плавающей точкой.
Пример использования float для преобразования строки:
#Пример преобразования string во float str_a = '50.85' b = 10.33 c = float(str_a) + b print ("The value of c = ",c)
Замечание: если вы попытаетесь использовать здесь функцию int(), то получите ошибку.
Если нужно преобразовать строки из чисел, содержащиеся в списке, тогда используйте генератора списков.
Будет создан новый список, в котором можно применить функцию int в каждой итерации.
Код:
#Пример преобразования string в int в списке str_lst = ['1', '2', '3'] int_lst = [int(x) for x in str_lst] print (int_lst)
Будет выведен новый список, состоящий из целых чисел, полученных из строк.
Аналогичным образом можно использовать float вместо int для преобразования списка, содержащего строки из целых чисел. Рассмотрим пример:
Код для преобразования элементов списка в числа с плавающей точкой:
#Пример преобразования string во float в списке str_lst = ['10.505', '2.3', '3.99'] float_lst = [float(x) for x in str_lst] print (float_lst)
Ну а как насчёт строки наподобие “5,000,000”? Если попытаетесь преобразовать ее, используя функции int() или float(), то получите ошибку.
Решением будет использование import locale. Например:
locale.setlocale(locale.LC_ALL, ‘en_US.UTF-8’ )
Но это может вызвать проблемы в остальных локалях. Другое решение заключается в том, чтобы заменить запятые пустыми строками, то есть“”, а затем использовать функцию int.
Код:
str_a = '5,123,000' int_b = int(str_a.replace(',','')) print ("The integer value",int_b)
В результате получаем целое значение. Это же решение можно применить для конвертации строки в число с плавающей точкой.
Пользовательский ввод в Python- программах воспринимается как строка. В следующем примере пользователя просят ввести год. После ввода значения программа сообщает, високосный это год или нет.
Для этого введённое значение сначала преобразуется в целое число, а затем используется формула расчёта високосного года.
#Пример расчёта високосного года try: Y = int(input("Enter a Year? ")) exceptValueError: print ("You may only enter digits in '2000' format!") else: leap_or_not = Y%4 == 0 ifleap_or_not: print ("Leap year") else: print ("Not a leap year")
Вводимая строка сразу преобразуется в целое число, а затем используется для расчёта.
Для преобразования целых чисел в строки в Python можно использовать функцию str(). Функция str() принимает объект, который может быть типа int, float, double и т.п.
Рассмотрим пример преобразования переменной типа int в строку, которая затем используется как строка для конкатенации:
#Примерпреобразованияint в string a_string = "str function for int to string" a_num = 456 print (a_string + str(a_num))
Вывод:
str function for int to string456
Если бы целочисленная переменная была использована без функции str(), возникла бы ошибка TypeError.
Данная публикация представляет собой перевод статьи «5 examples to Convert a Python string to int and float» , подготовленной дружной командой проекта Интернет-технологии.ру
Преобразование и приведение типов в Python
Из этой статьи вы узнаете что такое преобразование и приведение типов в Python и для чего это нужно. Для понимание материала этой статьи, вам сначала нужно ознакомиться со статьей «Типы данных в Python».
Преобразование типа
Процесс преобразования значения одного типа данных (целое число, строка, число с плавающей запятой и т.д.) в другой тип данных называется преобразованием типа. Python имеет два способа преобразования типов:
- Неявное преобразование типов
- Явное приведение типов
Неявное преобразование типов
При неявном преобразовании типов Python автоматически преобразует один тип данных в другой тип данных. Этот процесс не требует участия пользователя.
Давайте рассмотрим пример, в котором Python способствует преобразованию младшего типа данных (целое число) в более высокий тип данных (число с плавающей запятой), чтобы избежать потери данных.
Пример 1: преобразование целого числа в число с плавающей точкой
num_int = 123 num_float = 1.23 num_new = num_int + num_float print("тип данных num_int:",type(num_int)) print("тип данных num_float:",type(num_float)) print("значение num_new:",num_new) print("тип данных num_new:",type(num_new))
Давайте рассмотрим этот пример преобразования типа подробнее:
- мы добавляем две переменные num_int и num_float, сохраняя значение в num_new
- мы выводим тип данных всех трех объектов соответственно
- в выводе мы можем видеть, что тип данных num_int является целым числом, тип данных num_float — это число с плавающей точкой
- кроме того, мы можем видеть, что num_new имеет тип данных float, потому что Python всегда преобразует меньший тип данных в больший тип данных, чтобы избежать потери данных
Подробнее преобразование типа int в float и обратно, рассмотрено в статье Числа в Python.
Теперь давайте попробуем добавить строку и целое число и посмотрим, как Python отнесется к этому.
Пример 2: сложение строкового (более высокого) типа данных и целочисленного (более низкого) типа данных
num_int = 123 num_str = "456" print("тип данных num_int:",type(num_int)) print("тип данных num_str:",type(num_str)) print(num_int+num_str)
Если запустить приведенный выше пример, вы сначала увидите вывод типа данных двух наших переменных, а затем сообщение об ошибке. В данном случае, интерпретатор «не понял» что ему делать со значениями двух переменных, так как сложить число и строку не представляется возможным. Однако у Python есть решение для такого типа ситуаций, которое известно как явное преобразование.
Явное приведение типов
В явном преобразовании типов пользователи сами преобразуют тип данных объекта в требуемый тип данных. Мы используем предопределенные функции, такие как int(), float(), str() и т.д., чтобы выполнить явное преобразование типов.
Это преобразование типов также называется явным приведением типов, поскольку пользователь явно преобразует (изменяет) тип данных объектов.
Typecasting может быть выполнен путем назначения требуемой функции типа данных для выражения.
Пример 3: добавление строки и целого числа с использованием явного преобразования
num_int = 123 num_str = "456" print("тип данных num_int:",type(num_int)) print("тип данных num_str до приведения типа :",type(num_str)) num_str = int(num_str) print("тип данных num_str после приведения типа:",type(num_str)) num_sum = num_int + num_str print("сумма num_int и num_str:",num_sum) print("тип данных num_sum:",type(num_sum))
Ключевые моменты для запоминания
- Преобразование типов — это преобразование объекта из одного типа данных в другой тип данных.
- Неявное преобразование типов автоматически выполняется интерпретатором Python.
- Python позволяет избежать потери данных в неявном преобразовании типов.
- Явное преобразование типов также называется приведением типов, типы данных объекта преобразуются с использованием предопределенной функции.
- При приведении типов может произойти потеря данных, поскольку мы приводим объект к определенному типу данных.
Преобразование целого числа в строку в Python
Переполнение стека- Около
- Товары
- Для команд
- Переполнение стека Общественные вопросы и ответы
- Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
- работы Программирование и связанные с ним технические возможности карьерного роста
- Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
- реклама Обратитесь к разработчикам и технологам со всего мира
- О компании
Преобразование строк в числа и чисел в строки в Python
Введение
Python позволяет взаимозаменяемо преобразовывать строки, целые числа и числа с плавающей запятой несколькими различными способами. Самый простой способ сделать это — использовать базовые функции str ()
, int ()
и float ()
. Кроме того, есть еще несколько способов.
Прежде чем мы перейдем к преобразованию строк в числа и преобразованию чисел в строки, давайте сначала немного посмотрим, как строки и числа представлены в Python.
Примечание : Для простоты запуска и демонстрации этих примеров мы будем использовать интерпретатор Python.
Струны
Строковые литералы в Python объявляются заключением символа в двойные («) или одинарные кавычки (‘) знаки. Строки в Python на самом деле являются просто массивами с Unicode для каждого символа в качестве элемента в массиве, что позволяет использовать индексы для доступ к одному символу из строки.
Например, мы можем получить доступ к отдельным символам этих строк, указав индекс:
>>> stringFirst = "Hello World!"
>>> stringSecond = 'Снова!'
>>> stringFirst [3]
'l'
>>> stringSecond [3]
'я'
Числа
Числовое значение в Python может быть целым числом
, числом с плавающей запятой
или комплексным
.
Целые числа могут быть положительными или отрицательными целыми числами. Начиная с Python 3, целые числа не ограничены и могут содержать практически любое число. До Python 3 верхняя граница была 2 31 -1 для 32-разрядной среды выполнения и 2 63 -1 для 64-разрядной среды выполнения.
Float также имеет неограниченную длину, но число с плавающей запятой должно содержать десятичную точку.
Сложные числа должны иметь мнимую часть, которая обозначается с помощью j
:
>>> integerFirst = 23
>>> floatFirst = 23.23
>>> ComplextFirst = 1 + 23j
Преобразование строк в числа
Использование int () Функция
Если вы хотите преобразовать строку в целое число, самый простой способ — использовать функцию int ()
. Просто передайте строку в качестве аргумента:
>>> x = "23"
>>> y = "20"
>>> z = int (x) - int (y)
>>> г
3
Это работает, как ожидалось, когда вы передаете строковое представление целого числа в int ()
, но вы столкнетесь с проблемами, если переданная вами строка не содержит целочисленного значения.Если в вашей строке есть какие-либо нечисловые символы, тогда int ()
вызовет исключение:
>>> x = "23a"
>>> z = int (x)
Отслеживание (последний вызов последний):
Файл "", строка 1, в
ValueError: недопустимый литерал для int () с базой 10: '23a'
Это же исключение будет даже вызвано, если передана действительная строка с плавающей запятой:
>>> x = "23,4"
>>> z = int (x)
Отслеживание (последний вызов последний):
Файл "", строка 1, в
ValueError: недопустимый литерал для int () с базой 10: '23.4 '
У функции int ()
есть еще одна полезная функция, чем просто преобразование строк в целые числа, она также позволяет преобразовывать числа из любого основания в целое число с основанием 10. Например, мы можем преобразовать следующую двоичную строку в целое число с основанием 10, используя параметр base
:
>>> int ('1101100', основание = 2)
108
То же самое можно сделать для любой другой системы счисления, например с шестнадцатеричной системой счисления (основание 16):
>>> int ('6C', основание = 16)
108
Использование float () Функция
Преобразование строковых литералов в числа с плавающей запятой выполняется с помощью функции float ()
:
>>> x = "23.23 "
>>> y = "23.00"
>>> z = float (x) - float (y)
>>> г
0,23000000000000043
Обратите внимание, что результирующее значение не совсем точное, оно должно быть просто 0,23
. Это связано с математическими проблемами с плавающей запятой, а не с преобразованием строки в число.
Функция float ()
предлагает немного большую гибкость, чем функция int ()
, поскольку она может анализировать и преобразовывать как целые числа с плавающей точкой , так и :
>>> x = "23"
>>> y = "20"
>>> z = float (x) - float (y)
>>> г
3.0
В отличие от int ()
, float ()
не вызывает исключения, когда получает числовое значение, отличное от float.
Однако вызовет исключение, если ему будет передано нечисловое значение:
>>> x = "23a"
>>> z = float (x)
Отслеживание (последний вызов последний):
Файл "", строка 1, в
ValueError: не удалось преобразовать строку в float: '23a'
В то время как float ()
не имеет возможности , а не , имеет возможность преобразовывать числа, отличные от базовых 10, например int ()
, но не имеет возможности преобразовывать числа, представленные в научной нотации (также известной как электронная нотация):
>>> float ('23e-5')
0.00023
>>> float ('23e2')
2300,0
Использование комплекса () Функция
Преобразование строковых литералов в сложные числа выполняется с помощью функции complex ()
. Для этого строка должна иметь определенное форматирование. В частности, он должен быть отформатирован без пробелов вокруг операторов +
или -
:
>>> x = "5 + 3j"
>>> y = "3 + 1j"
>>> z = комплекс (x) + комплекс (y)
>>> г
(8 + 4j)
Наличие лишних пробелов между операторами +
или -
приведет к возникновению исключения:
>>> z = комплекс ("5+ 3j")
Отслеживание (последний вызов последний):
Файл "", строка 1, в
ValueError: complex () arg - неверно сформированная строка
Подобно функции float ()
, complex ()
также более расслаблен в типах чисел, которые она позволяет.Например, мнимая часть числа может быть полностью опущена, а также могут быть проанализированы как целые числа, так и числа с плавающей запятой:
>>> комплекс ("1")
(1 + 0j)
>>> сложный ("1,2")
(1,2 + 0j)
Однако, как видите, это не должно использоваться в качестве более гибкой замены для int
/ float
, поскольку оно автоматически добавляет мнимую часть числа к строковой версии.
Преобразование чисел в строки
Использование str () Функция
Функцию str ()
можно использовать для преобразования любого числового типа в строку.
Функция str ()
доступна в Python 3.0+, поскольку строки в Python 3.0+ по умолчанию являются Unicode. Однако это неверно для версий Python ниже 3.0 — в которых для достижения той же цели используется функция unicode ()
:
>>> str (23) # Целое в строку
'23'
>>> str (23.3) # Перевести в строку
'23,3 '
>>> str (5 + 4j) # Комплекс в строку
'(5 + 4j)'
Хорошая особенность str ()
заключается в том, что он может обрабатывать преобразование любого типа числа в строку, поэтому вам не нужно беспокоиться о выборе правильного метода в зависимости от того, какое число вы конвертируете.
Использование формата () Функция
Другой способ преобразования чисел в строки — использование функции format ()
, которая позволяет вам устанавливать заполнители внутри строки, а затем преобразовывать другой тип данных в строку и заполнять заполнители.
Чтобы использовать функцию, просто напишите строку, за которой следует .format ()
, и передайте аргументы для заполнителей.
Вот пример:
>>> "Мой возраст {}".формат (21)
"Мне 21 год"
Аргументы в функции .format ()
также могут упоминаться индивидуально, используя их позиции или имена переменных
python — преобразование строки в число?
Переполнение стека- Около
- Товары
- Для команд
- Переполнение стека Общественные вопросы и ответы
- Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
- работы Программирование и связанные с ним технические возможности карьерного роста
- Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
- реклама Обратитесь к разработчикам и технологам со всего мира
- О компании
python — преобразовать число с плавающей запятой до определенной точности, а затем скопировать в строку
Переполнение стека- Около
- Товары
- Для команд
- Переполнение стека Общественные вопросы и ответы
- Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
- работы Программирование и связанные с ним технические возможности карьерного роста
- Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
- реклама Обратитесь к разработчикам и технологам со всего мира
- О компании
Загрузка…
.