Как преобразовать и перевести строку (string) в целое число (int) в Python
В этом руководстве мы изучим способы преобразования строки в целое число в Python.
Давайте посмотрим на пример, прежде чем продолжить:
a='Learning Python is fun' b= 20 #Displaying the type of a and b print(type(a)) print(type(b))
Вывод:
<class 'str'> <class 'int'>
В приведенном выше примере мы объявили переменные ‘a’ и ‘b’ со строковым и целочисленным значением соответственно.
Мы можем проверить их типы данных с помощью type().
Здесь возникает вопрос, зачем нам преобразовывать строку в целое число.
Следующая программа иллюстрирует то же самое:
value_a = "100" value_b = "26" res = value_a * value_b print("The multiplication of val_a and val_b gives: ",res)
Вывод:
res = value_a * value_b TypeError: can't multiply sequence by non-int of type 'str'
Поскольку сгенерировалась ошибка, это причина того, что мы должны преобразовать строковые значения в целые числа, чтобы мы могли продолжить операцию.
Пришло время взглянуть на первую программу, демонстрирующую преобразование строки в целое число.
a = '7' print(type(a)) #using int() conv_a=int(a) print(type(conv_a)) conv_a = conv_a+10 print(conv_a) print(type(conv_a))
Вывод:
<class 'str'> <class 'int'> 17 <class 'int'>
Объяснение:
- Первый шаг – объявить переменную a со строковым значением.
- После этого мы проверили ее тип данных с помощью type().
- Для преобразования строки в целое число мы использовали int(), а затем проверили ее тип.
- Теперь мы поработали с переменной «а», добавив к ней 10.
- Наконец, на выходе отображается результирующее значение.
Подход 2.
В следующем примере мы применим косвенный подход к преобразованию строки в целое число.
Следующая программа показывает, как это можно сделать:
value_a = "100" value_b = "26" print(type(value_a)) print(type(value_b)) #converting to float value_a=float(value_a) #converting to int value_b=int(value_b) res_sum=value_a+value_b print("The sum of value_a and value_b is ",res_sum)
Вывод:
<class 'str'> <class 'str'> The sum of value_a and value_b is 126. 0
Объяснение:
- Первый шаг – объявить две переменные value_a и value_b со строковым значением.
- После этого проверили их тип данных с помощью type().
- Для преобразования строки в целое число мы использовали float() для преобразования строки в значение с плавающей запятой.
- На следующем шаге преобразуем строковое значение value_b в целое число.
- Теперь мы сложили value_a и value_b и распечатали их сумму.
- Наконец, на выходе отображается результирующее значение.
Подход 3.
Здесь мы увидим, как мы можем преобразовать число, представленное в виде строкового значения, в основание 10, когда оно находится на разных основаниях.
num_value = '234' # printing the value of num_value print('The value of num_value is :', num_value) #converting 234 to base 10 assuming it is in base 10 print('The value of num_value from base 10 to base 10 is:', int(num_value)) #converting 234 to base 10 assuming it is in base 8 print('The value of num_value from base 8 to base 10 is :', int(num_value, base=8)) #converting 234 to base 10 assuming it is in base 6 print('The value of num_value base 6 to base 10 is :', int(num_value, base=6))
Вывод:
The value of num_value is: 234 The value of num_value from base 10 to base 10 is: 234 The value of num_value from base 8 to base 10 is: 156 The value of num_value base 6 to base 10 is: 94
Объяснение:
- На первом этапе мы объявили значение переменной.
- Поскольку вывод всегда будет в базе 10, мы предоставили различные базовые значения внутри int().
- В качестве базовых значений мы взяли 10, 8 и 6.
- При выполнении программы отображается ожидаемый результат.
В этом руководстве мы узнали о различных способах преобразования строки в значение типа int.
Михаил Русаков
Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.
Еще для изучения:
Преобразование типов данных в Go
31 мая, 2019 12:41 пп 8 736 views | Комментариев нетВ Go типы данных используются для классификации данных по ряду характеристик, для определения значений, которые можно присвоить, и операций, которые можно выполнять над этими значениями. В программировании бывают случаи, когда нужно преобразовать значения одного типа в другой, чтобы по-другому с ними работать. Например, вам может потребоваться объединить числовые значения со строками или представить десятичные разряды в целочисленных значениях. Сгенерированным пользователем данным часто автоматически присваивается строковый тип, даже если эти данные состоят из чисел; для выполнения математических операций с этим вводом вам необходимо преобразовать строку в числовой тип данных.
Язык Go является статически типизированным, то есть типы данных в нем связаны с переменными, а не со значениями. Это означает, что если вы определяете переменную как int, она может быть только int. Позже вы не сможете присвоить ей строку, не преобразовав тип данных переменной. Статическая природа типов данных в Go – еще один важный повод подробно изучить способы их преобразования.
Читайте также: Основные типы данных в Go
В этом мануале вы на нескольких общих примерах научитесь преобразовывать числа и строки.
Преобразование числовых типов данных
Go имеет несколько числовых типов данных. В основном числа делятся на два основных типа: целые числа и числа с плавающей точкой.
Есть много ситуаций, в которых необходимо конвертировать один числовой тип в другой. Преобразование числовых типов из одного размера в другой может помочь оптимизировать производительность программы для определенной системной архитектуры. Если у вас в коде есть целое число и вы хотите разделить его, вы можете преобразовать целое число в число с плавающей точкой, чтобы получить точный результат. Кроме того, преобразование часто используется при работе с интервалами времени. Для решения этих ситуаций Go предлагает встроенные средства преобразования большинства числовых типов.
Преобразование целочисленных типов
Go поддерживает много целочисленных типов данных. Выбор одного или другого типа в основном зависит от его влияния на производительность; однако в некоторых случаях вам придется преобразовать один целочисленный тип в другой. Например, Go иногда автоматически генерирует числовые значения как int, а это может не соответствовать вашему входному значению. Если вы введете значение int64, вы не сможете использовать числа int и int64 в одном и том же математическом выражении, пока не преобразуете их типы данных соответствующим образом.
Предположим, у вас есть int8, и вам нужно преобразовать его в int32. Вы можете сделать это вот так:
var index int8 = 15
var bigIndex int32
bigIndex = int32(index)
fmt.Println(bigIndex)
15
Этот блок кода определяет index как тип данных int8 и bigIndex как тип данных int32. Чтобы сохранить значение index в bigIndex, он преобразует тип данных в int32. Для преобразования переменную index нужно заключить в int32().
Чтобы проверить тип данных, вы можете использовать оператор fmt.Printf и %T, для этого существует такой синтаксис:
fmt.Printf("index data type: %T\n",
fmt. Printf("bigIndex data type: %T\n", bigIndex)
index data type: int8
bigIndex data type: int32
Поскольку при этом используется оператор %T, оператор print выводит тип переменной, а не ее фактическое значение. Таким образом вы можете подтвердить, что тип данных был преобразован.
Вы также можете преобразовать большее целочисленное значение в меньшее целое число:
var big int64 = 64
var little int8
little = int8(big)
fmt.Println(little)
64
Имейте в виду, что при преобразовании целых чисел вы потенциально можете превысить максимальное значение типа данных:
var big int64 = 129
var little = int8(big)
fmt.Println(little)
-127
Сворачивание происходит, когда значение преобразуется в тип данных, который слишком мал для его хранения. В этом примере 8-битному типу данных int8 не хватило места для большого размера 64-битной переменной. При преобразовании большего типа данных в меньший тип всегда следует соблюдать осторожность, чтобы избежать случайного усечения данных.
Преобразование целых чисел в числа с плавающей точкой
Преобразование целых чисел в числа с плавающей точкой в Go похоже на преобразование одного целочисленного типа в другой. Вы можете использовать встроенные преобразования типов, заключая целое число в float64() или float32():
var x int64 = 57
var y float64 = float64(x)
fmt.Printf("%.2f\n", y)
57.00
Этот код объявляет переменную x типа int64 и инициализирует ее значение 57.
var x int64 = 57
float64() заключает в себя переменную x и преобразует значение 57 в значение с плавающей точкой 57.00.
var y float64 = float64(x)
Оператор %.2f позволяет fmt.Printf форматировать число с двумя десятичными знаками.
Вы также можете использовать этот процесс в переменной. Следующий код объявляет переменную f со значением 57, а затем выводит новое значение с плавающей точкой:
var f float64 = 57
fmt.Printf("%.2f\n", f)
57.00
Используя float32() или float64(), вы можете конвертировать целые числа в числа с плавающей точкой. Далее вы узнаете, как преобразовать числа с плавающей точкой в целые числа.
Преобразование чисел с плавающей точкой в целые числа
Go может преобразовывать числа с плавающей точкой в целые числа, но при этом программа теряет точность числа с плавающей точкой.
Для этого можно заключить число с плавающей точкой в int() (или же в один из архитектурно-независимых типов данных). Этот способ работает аналогично преобразованию одного целочисленного типа в другой. Вы можете добавить число с плавающей точкой в скобках, чтобы преобразовать его в целое число:
var f float64 = 390.8
var i int = int(f)
fmt. Printf("f = %.2f\n", f)
fmt.Printf("i = %d\n", i)
f = 390.80
i = 390
Этот синтаксис преобразует число с плавающей точкой 390,8 в целое число 390, сбрасывая десятичное значение.
Вы также можете использовать этот метод с переменными. Следующий код объявляет переменную b как 125.0 и переменную c как 390.8, а затем выводит их как целые числа. Краткое объявление переменной (:=) сокращает синтаксис:
b := 125.0
c := 390.8
fmt.Println(int(b))
fmt.Println(int(c))
125
390
При преобразовании чисел с плавающей точкой в целые числа с помощью int() Go обрезает десятичные значения, а оставшиеся числа с плавающей точкой образуют целое число. Обратите внимание, даже если вы захотите округлить 390,8 до 391, Go не сделает этого через тип int(). Вместо этого он опустит десятичную дробь.
Преобразование чисел через деление
В результате деления целочисленных типов в Go также получается целочисленный тип, а модуль или остаток сбрасываются:
a := 5 / 2
fmt. Println(a)
2
Если при делении любое из чисел является числом с плавающей точкой, то все типы будут автоматически объявлены как числа с плавающей точкой:
a := 5.0 / 2
fmt.Println(a)
2.5
Это делит число с плавающей точкой 5.0 на целое число 2, в результате чего получается 2.5 – число с плавающей точкой, которое сохраняет точность до десятых.
Преобразование строк
Строка – это последовательность из одного или нескольких символов (букв, цифр или других символов). Строки являются распространенной формой передачи данных в компьютерных программах, а потому преобразовывать строки в числа или числа в строки приходится довольно часто, особенно если программа принимает пользовательские данные.
Преобразование чисел в строки
Вы можете преобразовать числа в строки, используя метод strconv.Itoa из пакета strconv в стандартной библиотеке Go. Если вы передадите число или переменную в скобки метода, это числовое значение будет преобразовано в строковое.
Давайте посмотрим на преобразование целых чисел. Чтобы преобразовать целое число 12 в строковое значение, вы можете передать 12 методу strconv.Itoa:
package main
import (
"fmt"
"strconv"
)
func main() {
a := strconv.Itoa(12)
fmt.Printf("%q\n", a)
}
При запуске этой программы вы получите следующий вывод:
"12"
Кавычки вокруг числа 12 означают, что число больше не является целым числом как таковым, теперь оно является строковым значением.
В коде используется оператор присваивания :=, чтобы объявить новую переменную a и присвоить ей значение, возвращаемое функцией strconv.Itoa(). В этом случае вы присвоили переменной значение 12. Также тут используется оператор %q в функции fmt.Printf, которая заключает предоставленную строку в кавычки.
Переменные помогают понять, насколько практичным может быть преобразование целых чисел в строки. Допустим, вы хотите отслеживать ежедневный прогресс пользователя в программировании и для этого вам нужно знать, сколько строк кода пользователь пишет за раз. Вы хотели бы показать пользователю этот отзыв, где одновременно отображаются строковые и целочисленные значения:
package main
import (
"fmt"
)
func main() {
user := "8host"
lines := 50
fmt.Println("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
}
Когда вы запустите этот код, вы получите следующую ошибку:
invalid operation: ("Congratulations, " + user + "! You just wrote ") + lines (mismatched types string and int)
В Go объединять строки и целые числа нельзя, поэтому вам придется преобразовать переменную lines в строковые значения:
package main
import (
"fmt"
"strconv"
)
func main() {
user := "8host"
lines := 50
fmt.Println("Congratulations, " + user + "! You just wrote " + strconv.Itoa(lines) + " lines of code.")
}
Когда вы снова запустите код, вы получите следующий вывод, который поздравит пользователя с его прогрессом:
Congratulations, 8host! You just wrote 50 lines of code.
Если вы хотите преобразовать в строку не целое число, а число с плавающей точкой, выполните аналогичные шаги и форматирование. Когда вы передаете число с плавающей точкой в метод fmt.Sprint, из пакета fmt в стандартной библиотеке Go будет возвращено строковое значение с плавающей точкой. Вы можете использовать либо само значение с плавающей точкой, либо переменную:
package main
import (
"fmt"
)
func main() {
fmt.Println(fmt.Sprint(421.034))
f := 5524.53
fmt.Println(fmt.Sprint(f))
}
421.034
5524.53
Вы можете проверить и убедиться, что преобразование выполнено правильно, объединив строки:
package main
import (
"fmt"
)
func main() {
f := 5524.53
fmt.Println("8host has " + fmt.Sprint(f) + " points.")
}
8host has 5524.53 points.
Теперь вы можете быть уверены, что число с плавающей точкой правильно преобразовано в строку, потому что конкатенация была выполнена без ошибок.
Преобразование строк в числа
Строки могут быть преобразованы в числа с помощью пакета strconv в стандартной библиотеке Go. В пакете strconv есть функции для преобразования как целых чисел, так и чисел с плавающей точкой. Это очень распространенная операция при приеме ввода от пользователя. Например, если у вас есть программа, запрашивающая возраст человека, при вводе ответа возраст записывается в виде строки. Затем вам нужно преобразовать его в int для выполнения математических операций.
Если в вашей строке нет десятичных разрядов, вы можете преобразовать ее в целое число с помощью функции strconv.Atoi. Если вы знаете, что будете использовать число как число с плавающей точкой, нужно использовать strconv.ParseFloat.
Давайте для примера посмотрим, как пользователь 8host отслеживает строки кода, написанные каждый день. Возможно, вы захотите выполнить какие-то математические операции с этими значениями, чтобы разнообразить вывод для пользователя. Но пока что эти значения хранятся в строках:
package main
import (
"fmt"
)
func main() {
lines_yesterday := "50"
lines_today := "108"
lines_more := lines_today - lines_yesterday
fmt. Println(lines_more)
}
invalid operation: lines_today - lines_yesterday (operator - not defined on string)
Поскольку два числовых значения были сохранены в строках, вы получили ошибку. Операнд вычитания – нельзя использовать для строковых значений.
Измените код, включив в него метод strconv.Atoi(), который преобразует строки в целые числа. Это позволит вам выполнять математические операции со значениями, которые изначально были строками. Поскольку при преобразовании строки в целое число существует вероятность сбоя, вы должны проверить наличие ошибок. Для этого вы можете использовать оператор if:
package main
import (
"fmt"
"log"
"strconv"
)
func main() {
lines_yesterday := "50"
lines_today := "108"
yesterday, err := strconv.Atoi(lines_yesterday)
if err != nil {
log.Fatal(err)
}
today, err := strconv.Atoi(lines_today)
if err != nil {
log.Fatal(err)
}
lines_more := today - yesterday
fmt. Println(lines_more)
}
Поскольку строка может не быть числом, метод strconv.Atoi() будет возвращать как преобразованный тип, так и потенциальную ошибку. При преобразовании lines_yesterday с помощью функции strconv.Atoi необходимо проверить возвращаемое значение err и убедиться, что оно было преобразовано. Если err не равно nil, это означает, что метод strconv.Atoi не смог успешно преобразовать строковое значение в целое число. В этом примере мы использовали оператор if для проверки ошибки; если ошибка появлялась, log.Fatal регистрировал ее и выходил из программы.
Если вы запустите предыдущий код, вы получите:
58
Теперь попробуйте преобразовать строку, которая не является числом:
package main
import (
"fmt"
"strconv"
)
func main() {
a := "not a number"
b, err := strconv.Atoi(a)
fmt. Println(b)
fmt.Println(err)
}
Тут вы получите ошибку:
0
strconv.Atoi: parsing "not a number": invalid syntax
Поскольку переменная b была объявлена, но методу strconv.Atoi не удалось выполнить преобразование, переменной b не было присвоено значение. Обратите внимание, что b имеет значение 0. Это потому, что Go по умолчанию присваивает так называемые нулевые значения. Метод strconv.Atoi выдает ошибку и сообщает, почему не удалось преобразовать строку.
Преобразование строк и байтов
Строки в Go хранятся в виде фрагмента байтов. В Go вы можете преобразовать часть байт в строку, заключив ее в соответствующие методы []byte() и string():
package main
import (
"fmt"
)
func main() {
a := "my string"
b := []byte(a)
c := string(b)
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
}
Здесь мы сохранили строковое значение в a, затем преобразовали его во фрагмент байтов b, а после этого преобразовали фрагмент байтов обратно в строку как c. Затем a, b и c будут выведены на экран:
my string
[109 121 32 115 116 114 105 110 103]
my string
Первая строка вывода – это исходная строка my string. Вторая строка – это фрагмент байт, который составляет исходную строку. Третья строка показывает, что байты можно преобразовать обратно в строку и отобразить на экране.
Заключение
В этом мануале вы узнали, как преобразовать несколько важных типов данных в другие типы, в основном с помощью встроенных методов. Возможность конвертировать типы данных в Go позволяет вам принимать пользовательский ввод и выполнять математические операции для разных типов чисел. Позже, когда вы будете использовать Go для написания сложных программ, которые принимают данные из множества различных источников (баз данных и API), вы сможете использовать эти методы преобразования для работы с сданными. Вы также сможете оптимизировать хранение путем преобразования данных в меньшие типы.
Читайте также: Основные типы данных в Go
Tags: Go, GolangPython String to Int() и Int to String Tutorial
Как преобразовать строку Python в Int:
Чтобы преобразовать строку в целое число в Python, используйте функцию int()
. Эта функция принимает два параметра: исходную строку и необязательное основание для представления данных. Используйте синтаксис print(int("STR"))
, чтобы вернуть str
как int
или целое число.
Как преобразовать Python Int в строку:
Чтобы преобразовать целое число в строку в Python, используйте функцию str()
. Эта функция принимает данные любого типа и преобразует их в строку, включая целые числа. Используйте синтаксис print(str(INT))
, чтобы вернуть int
как str
или строку.
Найдите подходящий учебный лагерь
- Career Karma подберет для вас лучшие технологические учебные курсы
- Доступ к эксклюзивным стипендиям и подготовительным курсам
Выберите интересующий вас вопрос
Разработка программного обеспеченияДизайнОбработка и анализ данныхАналитика данныхUX-дизайнКибербезопасностьИмя
Фамилия
Электронная почта
Номер телефона
Продолжая, вы соглашаетесь с нашими Условиями обслуживания и Политикой конфиденциальности, а также соглашаетесь получать предложения и возможности от Career Karma по телефону, текстовым сообщениям и электронной почте.
Изучая программирование на Python, учащиеся быстро обнаруживают, что Python включает ряд типов данных, которые используются для различения определенного типа данных. Например, строки Python используются для представления текстовых данных, а целые числа могут представлять целые числа. Когда вы программируете, вам может понадобиться преобразовать значения между разными типами данных, чтобы вы могли работать с ними по-разному.
Одной из распространенных операций является преобразование строки Python в целое число или целого числа в строку. Python включает встроенные методы, которые можно использовать для выполнения этих преобразований: int()
и str()
.
В этом руководстве мы рассмотрим, как можно использовать метод int()
для преобразования строки в целое число в Python. Мы также обсудим, как использовать str()
для преобразования целого числа в строку.
Типы данных Python
Когда вы программируете на Python, данные, с которыми вы работаете, будут храниться различными способами. Если вы работаете с текстом, ваши данные будут храниться в виде строки. Но если вы работаете с десятичным числом, ваши данные будут структурированы как числа с плавающей запятой.
Это важно, потому что с каждым типом данных можно работать по-разному. Таким образом, Python должен хранить разные типы данных, используя разные типы данных. В Python есть несколько типов данных, которые используются для хранения данных, включая числа, логические значения и списки.
В этой статье мы сосредоточимся на двух из этих типов данных: строках и числах.
В Python строки заключаются в одинарные или двойные кавычки и используются для представления текстовой информации. Вот пример строки:
text_data = «Эта строка содержит текстовые данные».
Тип данных число используется для хранения как десятичных, так и целых чисел. Десятичные числа будут автоматически преобразованы в числа с плавающей запятой, а целые числа будут считаться целыми числами. Вот пример целого числа и числа с плавающей запятой в Python:
пример_целого = 22 example_float = 2. 22
Преобразование типа данных в другую форму данных называется преобразованием типа . Если вы хотите преобразовать строку в целое число или целое число в строку, вы будете выполнять операцию преобразования типа
Python String to Int
Метод int()
можно использовать для преобразования строки в целое число. значение в Питоне.
int()
принимает два параметра: строку, которую необходимо преобразовать в целое число, и базу, в которой должны быть представлены ваши данные. Второй параметр является необязательным.
Метод возвращает значение, которое вы передали через int()
, представленное как целое число. Вот синтаксис метода Python int()
:
int(number, base=base)
Вот пример метода int()
, используемого для преобразования строки в целое число:
print( int("12"))
Наш код возвращает:
Пример String to Int в действии
Давайте используем более подробный пример, чтобы показать, как int() 9Можно использовать метод 0008. Допустим, мы создаем форму регистрации для детской игры, которая запрашивает возраст пользователя. Нам нужно, чтобы это значение хранилось как целое число в нашей базе данных. Но когда пользователь вставляет значение в нашу программу, его возраст становится строкой.
Создадим программу, выполняющую эту функцию. Мы начнем с использования метода input()
для получения возраста пользователя:
raw_user_age = input("Каков ваш возраст?") print(raw_user_age)
Когда наш пользователь вводит число, оно будет выведено на консоль. Вот что происходит, когда мы запускаем нашу программу:
Сколько тебе лет? 12 12
Введенное пользователем значение равно 12
. Это может выглядеть как число. Однако когда мы используем метод type()
для проверки типа данных на предмет возраста нашего пользователя, мы видим, что это не число. Мы можем использовать следующий код для проверки типа данных возраста нашего пользователя:
print(type(raw_user_age))
Наш код возвращает:
Как видите, наши данные сохранены как str
или строка. Итак, ясно, что нам нужно преобразовать наши данные в целое число. Мы можем сделать это, используя следующий код:
raw_user_age = input("Сколько вам лет?") user_age = int (raw_user_age) print(user_age)
Вот что произойдет, когда мы выполним наш код и вставим значение 12
:
Каков ваш возраст? 12 12
Наш код возвращает тот же результат, что и выше, но 12
теперь хранится как целое число. Мы можем использовать метод type()
для проверки:
print(type(user_age))
Наш код возвращает:
Теперь наше значение хранится как целое число, как мы изначально хотели .
Python Int to String Метод str() позволяет преобразовать целое число в строку в Python. Синтаксис этого метода:
«Карьерная карма вошла в мою жизнь, когда я больше всего в ней нуждалась, и быстро помогла мне пройти буткемп. Через два месяца после выпуска я нашла работу своей мечты, которая соответствовала моим ценностям и целям в жизни! "
Венера, инженер-программист Rockbot
str(number_to_convert)
Давайте рассмотрим пример, чтобы показать, как работает этот метод. В нашем предыдущем примере мы преобразовали возраст пользователя в целое число, используя этот код:
raw_user_age = input("Сколько вам лет?") user_age = int (raw_user_age)
Допустим, мы хотим вывести на консоль сообщение с возрастом нашего пользователя. Мы могли бы сделать это, используя следующий код:
print("Ваш возраст: " + user_age)
Наш код возвращает ошибку:
Трассировка (последний последний вызов): Файл «main.py», строка 3, вprint("Ваш возраст: " + user_age) TypeError: может только конкатенировать str (не "int") в str
Это связано с тем, что вы не можете объединить строку с целым числом, как мы пытались сделать выше. Чтобы наш код работал, нам нужно преобразовать возраст нашего пользователя в строку. Мы можем сделать это с помощью метода str()
:
raw_user_age = input("Каков ваш возраст?") user_age = int (raw_user_age) as_string = строка (возраст_пользователя) print("Ваш возраст: " + as_string)
Наш код возвращает:
Сколько вам лет?
12
Ваш возраст: 12
Мы успешно преобразовали целое число в строку с помощью функции str(). Оба значения теперь являются строками, что означает, что теперь мы можем объединить сообщение Your age is:
с возрастом пользователя.
Python Преобразование списка строк в список целых чисел
Предположим, у нас есть список строк, содержащий оценки, полученные учащимися на уроке информатики. Мы хотим преобразовать каждую оценку в нашем списке в целое число. Для этого мы можем использовать понимание списка Python.
Понимание списков упрощает создание нового списка на основе содержимого существующего списка. В этом случае мы будем использовать понимание списка, чтобы превратить список строк в новый список целых чисел.
Рассмотрим этот код:
оценок = ["82", "84", "71", "64", "66"] new_grades = [int(g) для g в оценках] print(new_grades)
Во-первых, мы определяем список под названием «grades». Этот список содержит строки. Затем мы пишем генератор списка, который преобразует каждое значение в нашем списке «оценок» в целое число. Наше понимание списка делает это, перебирая каждое значение в «оценках» и изменяя их тип данных с помощью функции int().
В конце нашей программы мы печатаем наш новый список целых чисел:
[82, 84, 71, 64, 66]
Наш код успешно преобразовал наш список строк в список целых чисел.
Заключение
Метод int() используется для преобразования строки в целое число в Python. Это может быть полезно, если вам нужно сохранить значение как целое число или выполнить математические операции со значением, хранящимся в виде строки. Метод str() используется для преобразования целого числа в строку.
Теперь вы готовы преобразовывать строки в целые числа в Python, как эксперт!
Как преобразовать строку Python в int — Real Python
Смотреть сейчас Это руководство содержит соответствующий видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным учебным пособием, чтобы углубить свое понимание: Преобразование строки Python в целое число
Целые числа — это целые числа. Другими словами, они не имеют дробной составляющей. Два типа данных, которые вы можете использовать для хранения целых чисел в Python, — это 9.0007 int и str
. Эти типы обеспечивают гибкость для работы с целыми числами в различных обстоятельствах. В этом руководстве вы узнаете, как преобразовать строку Python в int
. Вы также узнаете, как преобразовать int
в строку.
К концу этого урока вы поймете:
- Как хранить целые числа, используя
str
иint
- Как преобразовать строку Python в
int
- Как преобразовать Python
int
в строку
Начнем!
Пит-стоп Python: Это руководство представляет собой быстрый и практичный способ найти нужную информацию, так что вы вернетесь к своему проекту в кратчайшие сроки!
Бесплатный бонус: Нажмите здесь, чтобы получить шпаргалку по Python и изучить основы Python 3, такие как работа с типами данных, словарями, списками и функциями Python.
Представление целых чисел в Python
Целое число может храниться с использованием различных типов. Два возможных типа данных Python для представления целого числа:
-
ул
-
внутр.
Например, вы можете представить целое число с помощью строкового литерала:
>>>
>>> с = "110"
Здесь Python понимает, что вы имеете в виду, что вы хотите сохранить целое число 110
в виде строки. Вы можете сделать то же самое с целочисленным типом данных:
>>>
>>> я = 110
Важно учитывать, что конкретно вы подразумеваете под "110"
и 110
в приведенных выше примерах. Как человеку, который всю свою жизнь использовал десятичную систему счисления, может быть очевидно, что вы имеете в виду число сто десять . Однако существует несколько других систем счисления, таких как двоичная и шестнадцатеричная , которые используют разные основания для представления целого числа.
Например, вы можете представить число сто десять в двоичном и шестнадцатеричном виде как 1101110 и 6e соответственно.
Вы также можете представлять свои целые числа с другими системами счисления в Python, используя типы данных str
и int
:
>>>
>>> двоичный = 0b1010 >>> шестнадцатеричное = "0xa"
Обратите внимание, что двоичная
и шестнадцатеричная
используют префиксы для идентификации системы счисления. Все целочисленные префиксы имеют форму 0?
, в котором вы заменяете ?
с символом, который относится к системе счисления:
- b: двоичный (основание 2)
- o: восьмеричное (основание 8)
- d: десятичный (основание 10)
- x: шестнадцатеричный (основание 16)
Техническая информация: Префикс не требуется ни в целочисленном, ни в строковом представлении, если его можно вывести.
int
предполагает, что буквальное целое число равно 9SyntaxError: неверный синтаксис
Строковое представление целого числа является более гибким, поскольку строка содержит произвольные текстовые данные:
>>>
>>> decimal = "303" >>> шестнадцатеричный_с_префиксом = "0x12F" >>> шестнадцатеричный_но_префикс = "12F"
Каждая из этих строк представляет одно и то же целое число.
Теперь, когда у вас есть некоторые базовые знания о том, как представлять целые числа, используя str
и int
, вы узнаете, как преобразовать строку Python в интервал
.
Удалить рекламу
Преобразование строки Python в
int
Если у вас есть десятичное целое число, представленное в виде строки, и вы хотите преобразовать строку Python в int
, вы просто передаете строку int()
, которая возвращает десятичное целое число:
>>>
>>> целое ("10") 10 >>> тип(целое("10")) <класс 'целое число'>
По умолчанию int()
предполагает, что строковый аргумент представляет десятичное целое число. Однако если вы передадите шестнадцатеричную строку int()
, то вы увидите ValueError
:
>>>
>>> интервал ("0x12F") Traceback (последний последний вызов): Файл "", строка 1, в ValueError: неверный литерал для int() с основанием 10: '0x12F'
В сообщении об ошибке говорится, что строка не является допустимым десятичным целым числом.
Примечание:
Важно понимать разницу между двумя типами ошибочных результатов передачи строки в int()
:
- Синтаксическая ошибка: Ошибка
ValueError
возникает, когдаint()
не знает, как анализировать строку, используя предоставленную базу (10 по умолчанию). - Логическая ошибка:
int()
умеет анализировать строку, но не так, как вы ожидали.
Вот пример логической ошибки:
>>>
>>> binary = "11010010" >>> int(binary) # Использование по умолчанию базы 10 вместо 2 11010010
В этом примере вы хотели, чтобы результатом было 210 , что является десятичным представлением двоичной строки. К сожалению, поскольку вы не указали это поведение, int()
предположила, что строка представляет собой десятичное целое число.
Хорошей защитой от такого поведения является всегда определение ваших строковых представлений с использованием явных оснований:
>>>
>>> int("0b11010010") Traceback (последний последний вызов): Файл "", строка 1, в ValueError: неверный литерал для int() с основанием 10: '0b11010010'
Здесь вы получаете ValueError
, потому что int()
не знает, как анализировать двоичную строку как десятичное целое число.
Когда вы передаете строку в int()
, вы можете указать систему счисления, которую вы используете для представления целого числа. Способ указать систему счисления — использовать с основанием
:
>>>
>>> int("0x12F", base=16) 303
Теперь int()
понимает, что вы передаете шестнадцатеричную строку и ожидаете десятичное целое число.
Техническая деталь: Аргумент, который вы передаете по основанию
, не ограничен 2, 8, 10 и 16:
>>>
>>> int("10", base=3) 3
Отлично! Теперь, когда вы знакомы с тонкостями преобразования строки Python в int
, вы узнаете, как выполнить обратную операцию.
Преобразование Python
int
в строку В Python вы можете преобразовать Python int
в строку с использованием str()
:
>>>
>>> ул(10) «10» >>> тип (стр (10)) <класс 'ул'>
По умолчанию str()
ведет себя как int()
в том смысле, что приводит к десятичному представлению:
>>>
>>> ул(0b11010010) «210»
В этом примере str()
достаточно умен, чтобы интерпретировать двоичный литерал и преобразовать его в десятичную строку.
Если вы хотите, чтобы строка представляла целое число в другой системе счисления, используйте форматированную строку, такую как f-строка (в Python 3.6+), и параметр, указывающий базу:
.>>>
>>> восьмеричное = 0o1073 >>> f"{восьмеричный}" # Десятичный '571' >>> f"{восьмеричный:x}" # Шестнадцатеричный "23б" >>> f"{octal:b}" # Двоичный '1000111011'
str
— это гибкий способ представления целого числа в различных системах счисления.
Удалить рекламу
Заключение
Поздравляем! Вы так много узнали о целых числах и о том, как представлять и преобразовывать их между типами данных Python string и int
.
В этом уроке вы узнали:
- Как использовать
str
иint
для хранения целых чисел - Как указать явную систему счисления для целочисленного представления
- Как преобразовать строку Python в
int
- Как преобразовать Python
int
в строку
Теперь, когда вы так много знаете о str
и int
, вы можете больше узнать о представлении числовых типов с помощью float()
, hex()
, oct()
и bin()
!
Смотреть сейчас Это руководство содержит связанный с ним видеокурс, созданный командой Real Python.