Методы преобразования кортежа в строку в python

Введение

Строки (strings) в Python представляют собой последовательности из одного или более знаков (букв, цифр, символов). И хотя мы можем использовать эту последовательность в каких-то операциях, сама она является неизменной. То есть строку нельзя изменить, не создав при этом другой объект, занимающий иной адрес в памяти.

Благодаря широкому распространению текста в повседневной жизни, строка является важным типом данных, присутствующим в мире программирования.

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

Повторение строк

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

Давайте выведем на экран 9 раз с помощью оператора .

print("Sammy" * 9)

SammySammySammySammySammySammySammySammySammy

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

Преобразование типов данных в Python

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

Например так можно преобразовать тип int в float:

float_number = float(5)
print(float_number)
5.0

Преобразование числа типа float в int приведет к округлению в сторону нуля:

int_number = int(12.6)
print(int_number)
12

При преобразовании строки в число, строка должна содержать подходящее значение:

number = float('12')
print(number)
12

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

При попытке преобразования строки ‘4g’ возникла ошибка.

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

print(set())
{1, 2, 3}
print(tuple({5,6,7}))
(5, 6, 7)
print(list('hello'))

блок 3

Функции type() и ‘isinstance() в Python

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

Приведенный выше код выдает в качестве результата ‘int’. Тип данных переменной является целочисленным, и функция определяет его именно таким образом.

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

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

Подсказки типов и модуль mypy

У динамически типизированных языков, таких как Python, есть свои мощные преимущества, но есть и некоторые недостатки. Одним из недостатков является возникновение ошибок выполнения (runtime error) когда Python не производит принудительного преобразования типов. В результате могут возникать баги, которые с увеличением длины кода становится все трудней найти.

Подсказки типов реализованы в Python начиная с версии 3.5. А более старые версии могут не поддерживать данный функционал.

Давайте посмотрим простой пример без подсказок типов и модуля mypy.

Данная функция предназначена для вычитания целочисленных значений. Она принимает на вход два целых числа и возвращает их разность.

def sub_this(x,y):
    return 'Subtraction'
print(sub_this(8,'hello')) 

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

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

mypy — это модуль Python, который помогает в проверке статических типов. Он использует собственную динамическую проверку Python или неявную («утиную») типизацию с подсказкой самого типа.

Для начала вам нужно установить сам модуль mypy:

Далее вам нужно создать файл с именем mypy_example.py на своем локальном компьютере и сохранить туда следующий код:

def sub_this(x:int,y:int) -> int:
    return 'Subtracted two integers'
print(sub_this(8,4)) 

Это простая программа, которая принимает два целых числа в качестве входных данных в параметре, а после ‘->’ показывает тип возвращаемых данных, который также является целочисленным (‘int’). Но хотя функция должна возвращать целочисленное значение (int), возвращается строка ‘Subtracted two integers’.

Запустите указанный выше код в терминале следующим образом:

После этого будет показана ошибка, указывающая на несоответствие типов (должен быть ‘int», а выдается ‘str’).

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

def sub_this(x:int,y:int) -> int:
    return x - y
print(sub_this(8,4)) 

Мы видим, что программа выполняется успешно, никаких проблем не обнаружено.

Преобразование типа

Процесс преобразования значения одного типа данных (целое число, строка, число с плавающей запятой и т.д.) в другой тип данных называется преобразованием типа. 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))

блок 1

Давайте рассмотрим этот пример преобразования типа подробнее:

1. мы добавляем две переменные num_int и num_float, сохраняя значение в num_new
2. мы выводим тип данных всех трех объектов соответственно
3. в выводе мы можем видеть, что тип данных num_int является целым числом, тип данных num_float — это число с плавающей точкой
4. кроме того, мы можем видеть, что 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))

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

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

Давайте соединим строки и вместе с помощью функции :

 print("Sammy" + "Shark")

SammyShark

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

print("Sammy" + 27)

TypeError: Can't convert 'int' object to str implicitly

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

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

Десятичные дроби в Python

Встроенный в Python класс float выполняет некоторые вычисления, которые могут нас удивить. Мы все знаем, что сумма 1.1 и 2.2 равна 3.3, но Python, похоже, не согласен.

>>> (1.1 + 2.2) == 3.3
False

Оказывается, что числа с плавающей запятой реализованы в Python как двоичные дроби, поскольку компьютер понимает только двоичную систему счисления (0 и 1). По этой причине большинство известных нам десятичных дробей не может быть точно сохранено на нашем компьютере.

Давайте рассмотрим пример. Мы не можем представить дробь 1/3 как десятичное число. Это даст 0.33333333.

Получается, что десятичная дробь 0,1 приведет к бесконечно длинной двоичной дроби 0,000110011001100110011 … и наш компьютер хранит только ее конечное число.

Это будет только приблизительно 0,1, но никогда не будет равным 0,1. Следовательно, это ограничение нашего компьютерного оборудования, а не ошибка в Python.

>>> 1.1 + 2.2
3.3000000000000003

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

import decimal

# Результат: 0.1
print(0.1)

# Результат: Decimal('0.1000000000000000055511151231257827021181583404541015625')
print(decimal.Decimal(0.1))

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

Разные

ascii()	Он возвращает строку, содержащую печатную форму объекта, и игнорирует значения, отличные от ASCII, в строке	ascii(объект)
bool()	Он возвращает логическое значение, то есть True или False для объекта.	bool(значение)
bytearray()	Он возвращает объект, содержащий массив байтов, предоставленных через ввод	bytearray(источник, кодировка, ошибки)
bytes()	Он возвращает объект байтов, который не может быть изменен и представляет собой последовательность целых чисел в диапазоне от 0 до 255.	bytes(источник, кодировка, ошибки)
enumerate()	Он используется для добавления счетчика к итерируемому объекту, а затем возвращает его значение	enumerate(итерация, начало = 0)
float()	Возвращает число с плавающей запятой из заданного аргумента.	float (аргумент)
hash()	Возвращает хеш-значение объекта, если применимо.	hash(объект)
id()	Он возвращает конкретную идентификацию объекта, которая является уникальным целым числом.	id(объект)
int()	Он возвращает целочисленный объект из заданного ввода, и база возвращаемого объекта всегда будет 10	int (x = 0, основание = 10)
len()	Возвращает длину последовательности, т.е. количество элементов в объекте.	len (последовательность)
map()	Он используется для применения заданной функции к каждому элементу итерации, который может быть кортежем, списком и т. Д., А также возвращает список, содержащий результирующие значения.	map(функция, итерация, …)
ord()	Он принимает строковый аргумент из одного символа Unicode и возвращает его точку уважения Unicode	ord(символ)
print()	Он печатает предоставленный объект на любом устройстве вывода	print (объект (ы), separator = separator, end = end, file = file, flush = flush)
slice()	Он создает объект, который представляет собой набор индексов, заданных его диапазоном (начало, остановка, шаг).	slice (стоп) срез (начало, остановка, шаг)
type()	Возвращает тип объекта	type(объект) тип (имя, базы, dict)

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

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

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

S.No.	Функция & Описание
1	int(x ) Преобразует x в целое число.
2	float(x) Преобразует x в число с плавающей запятой.
3	complex(real ) Создает комплексное число.
4	str(x) Преобразует объект x в строковое представление.
5	repr(x) Преобразует объект x в строковое выражение.
6	eval(str) Обрабатывает строку и возвращает объект. Используется для выполнения программного кода представленного сторокой.
7	tuple(s) Преобразует s в кортеж.
8	list(s) Преобразует s в список.
9	set(s) Преобразует s в набор.
10	dict(d) Создает словарь. d должен быть последовательностью (ключ, значение) кортежей.
11	frozenset(s) Преобразует s в неизменяемый набор.
12	chr(x) Преобразует целое число в символ.
13	unichr(x) Преобразует целое число в символ Unicode.
14	ord(x) Преобразует один символ в его целочисленное значение.
15	hex(x) Преобразует целое число в шестнадцатеричную строку.
16	oct(x) Преобразует целое число в восьмеричную строку.

Что такое динамическая типизация

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

• типизированные языки;
• нетипизированные (бестиповые) языки.

Нетипизированные языки в основной своей массе сосредоточены на низком уровне, где большинство программ напрямую взаимодействует с железом. Так как компьютер «мыслит» нулями и единицами, различия между строкой и, допустим, классом для него будут заключаться лишь в наборах этих самых 0 и 1. В связи с этим, внутри бестиповых языков, близких к машинному коду, возможны любые операции над какими угодно данными. Результат на совести разработчика.

Python же — язык типизированный. А, раз в нём определено понятия «типа», то должен существовать и процесс распознания и верификации этих самых «типов». В противном случае вероятны ситуации, когда логика кода окажется нарушенной, а программа выполнится некорректно.

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

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

В языке со статической типизацией такой фокус не пройдёт:

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

К плюсам динамической типизации можно отнести:

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

2. Абстрагирование в алгоритмах.
Создавая на Питоне, предположим, функцию сортировки, можно не писать отдельную её реализацию для строк и чисел, поскольку она и так корректно отработает на любом компарируемом множестве.

3. Простота изучения.
Не секрет, что изучать Питон с нуля гораздо легче, чем, например, Java. И такая ситуация будет наблюдаться не только для этой пары. Языки с динамической типизацией в большинстве своём лучше подходят в качестве учебного инструмента для новичков в программировании.

К минусам же динамической проверки типов можно отнести такие моменты, как:

1. Ошибки.
Ошибки типизации и логические ошибки на их основе. Они достаточно редки, однако зачастую весьма сложно отлавливаемы. Вполне реальна ситуация, когда разработчик писал функцию, подразумевая, что она будет принимать числовое значение, но в результате воздействия тёмной магии или банальной невнимательности, ей на вход поступает строка и …функция отрабатывает без ошибок выполнения, однако её результат, – ошибка, сам по себе. Статическая же типизация исключает такие ситуации априори.

2. Оптимизация.
Статически типизированные языки обычно работают быстрее своих динамических братьев, поскольку являются более «тонким» инструментом, оптимизация которого, в каждом конкретном случае, может быть настроена более тщательно и рационально.

Так или иначе, сказать, что «одно лучше другого» нельзя. Иначе «другого» бы не было. Динамически типизированные языки экономят уйму времени при кодинге, но могут обернуться неожиданными проблемами на этапе тестирования или, куда хуже, продакшена. Однако вряд ли кто-то будет спорить с тем, что динамический Python куда более дружелюбный для новичков, нежели статический C++.

Последовательности

Ещё одно понятие из математики. Там, последовательность – есть нумерованный набор элементов, в котором возможны их повторения, а порядок имеет значение. Определение Питона схоже с математическим: здесь последовательностью зовётся упорядоченная коллекция объектов.

str (строка)

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

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

Строки, строки everywhere!

list (список)

Список – это ещё один вид последовательностей… Здесь стоит остановиться и отметить, что последовательности в Python бывают изменяемыми и неизменяемыми. Список – изменяемая последовательность, а строки и кортежи – нет. Таким образом, список можно определить, как упорядоченную и изменяемую коллекцию, состоящую из объектов произвольных типов.

Само название списков говорит об их предназначении быть объектами для хранения наборов данных. Список покупок, подарков, результатов матчей, ip клиентов или объектов типа Student. Списки в Python – это эдакие массивы из прочих языков «на максималках».

tuple (кортеж)

Кортежи в языке Python можно рассматривать, как неизменяемые списки со всеми вытекающими:

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

Операции со строками в Python

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

Конкатенация двух или более строк

Объединение двух или более строк в одну называется конкатенацией. В Python конкатенация выполняется оператором +.

Оператор * может использоваться для повторения строки в течение заданного числа раз.

str1 = 'Hello'
str2 ='World!'

# Конкатенация (объединение) строк
print('str1 + str2 = ', str1 + str2)

# Повторение строк
print('str1 * 3 =', str1 * 3)

Перебор строк

Используя цикл for, мы можем перебирать строку.

Пример для подсчета количества символа ‘l’ в строке.

count = 0
for letter in 'Hello World':
    if(letter == 'l'):
        count += 1
print(count)

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

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

>>> 'a' in 'programfiles'
True
>>> 'at' not in 'programfiles'
False

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

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

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

# Set Example
myset = {"hi", 2, "bye", "Hello World"}

# loop through set
for a in myset:
    print(a)

# checking whether 2 exists in myset
print(2 in myset)

# adding new element
myset.add(99)
print(myset)

Далее мы вводим некоторые другие операции для задания типов данных

([1,>

Метод add() добавляет элемент в набор. Элемент remove() удаляет элемент из набора. Метод clear() удаляет все элементы из набора. set1 является надмножеством set2, если каждый элемент в set2 также находится в set1. set1 является подмножеством set2, если каждый элемент в set1 также находится в set2.

set()
set()
Is set1 subset of set2 ? :  True
Is set1 superset of set2 ? :  False
set([])

Если нам нужен неизменяемый набор, мы можем создать замороженный набор с помощью функции frozenset().

([‘a’,>

Эта строка создает замороженный набор из списка.

Форматирование строк в Python

Экранирование символов

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

>>> print("She said, "What's there?"")
...
SyntaxError: invalid syntax
>>> print('She said, "What's there?"')
...
SyntaxError: invalid syntax

Один из способов обойти эту проблему — использовать тройные кавычки. В качестве альтернативы мы можем использовать escape-последовательности или так называемое «экранирование символов».

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

# Тройные кавычки
print('''He said, "What's there?"''')

# Экранирование одинарных кавычек
print('He said, "What\'s there?"')

# Экранирование двойных кавычек
print("He said, \"What's there?\"")

Использование метода format() для форматирования строк

Метод format(), доступный для строкового объекта, очень универсален и мощен в форматировании строк. Формат строки содержит фигурные скобки {} в качестве заполнителей или заменяющих полей, которые заменяются соответствующими значениями.

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

# порядок по умолчанию
default_order = "{}, {} and {}".format('John','Bill','Sean')
print(default_order)

# порядок задается вручную
positional_order = "{1}, {0} and {2}".format('John','Bill','Sean')
print(positional_order)

# порядок задается аргументами
keyword_order = "{s}, {b} and {j}".format(j='John',b='Bill',s='Sean')
print(keyword_order)

Метод format() может иметь необязательные спецификации формата. Они отделены от имени поля двоеточием. Например, мы можем выравнивать по левому краю <, выравнивать по правому краю > или центрировать ^ строку в заданном пространстве. Мы также можем отформатировать целые числа как двоичные, шестнадцатеричные и т.д., а числа с плавающей точкой могут быть округлены или отображены в формате экспоненты. Существует множество форматов, которые вы можете использовать. Более подробно про метод format() можно почитать в официальной документации к языку.

>>> # форматирование целых чисел
>>> "Binary representation of {0} is {0:b}".format(12)
'Binary representation of 12 is 1100'

>>> # форматирование чисел с плавающей запятой
>>> "Exponent representation: {0:e}".format(1566.345)
'Exponent representation: 1.566345e+03'

>>> # округление
>>> "One third is: {0:.3f}".format(1/3)
'One third is: 0.333'

>>> # выравнивание строки
>>> "|{:<10}|{:^10}|{:>10}|".format('butter','bread','ham')
'|butter | bread | ham|’

Расширенные строковые функции Python

encode()	Используется для возврата закодированных строк	str_name.encode (кодировка = кодировка, ошибки = ошибки)
expandtabs()	Для установки или исправления пробелов табуляции между символами или алфавитами	str_name.expandtabs (размер табуляции)
format()	Заменяет имя переменной, записанное в {}, значением при выполнении	str_name.format (значение1, значение2 …)
format_map()	Для форматирования заданной строки и возвращается	str_name.format_map (отображение)
isidentifier()	Проверяет, являются ли символы буквенно-цифровыми буквами (az) и (0-9) или подчеркиванием (_), и возвращает True	str_name.isidentifier()
isprintable()	Проверяет, все ли символы доступны для печати, затем возвращает True	str_name.isprintable()
istitle()	Проверяет, все ли начальные символы слов в верхнем регистре, затем возвращает True	str_name.istitle()
join()	Принимает слова как повторяемые и объединяет их в строку	str_name.join (повторяемый)
ljust()	Возвращает выровненную по левому краю строку с минимальным значением, заданным как ширина	str_name.ljust (длина, символ)
lstrip()	Удаляет символы с левого края на основе данного аргумента	str_name.lstrip (символы)
maketrans()	Создает сопоставленную таблицу, используемую для переводов.	str_name.maketrans (x, y, z)
rsplit()	Используется для разделения строки с правого конца	str_name.rsplit (разделитель, maxsplit)
rfind()	Ищет указанное значение и находит позицию его последнего значения.	str_name.rfind (значение, начало, конец)
rindex()	Ищет указанное значение и находит позицию его последнего значения.	str_name.rindex (значение, начало, конец)
rjust()	Возвращает выровненную по правому краю строку с минимальным значением, заданным как ширина	str_name.rjust (длина, символ)
rpartition()	Ищет последнее вхождение указанной строки и разбивает строку на кортеж из трех элементов.	str_name.rpartition (значение)
rstrip()	Удаляет символы с правого конца на основе заданного аргумента	str_name.rstrip (символы)
translate()	Используется для получения переведенной строки	str_name.translate (таблица)
zfill()	Он возвращает новую строку с символами «0», добавленными слева в строке.	str_name.zfill (len)

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

Мы можем преобразовать int в float с помощью функции float(). Точно так же мы можем использовать функцию int() для преобразования числа с плавающей запятой в int.

Мы можем использовать функцию complex() для преобразования int или float в комплексное число, мнимая часть будет 0j.

Мы не можем преобразовать комплексное число в int или float.

i = 10
f = 10.55

# int to float conversion
f1 = float(i)
print(f1)
print(type(f1))

# float to int conversion
i1 = int(f)
print(i1)
print(type(i1))

# int and float to complex number conversion
c = complex(i)
print(c)
print(type(c))

c = complex(f)
print(c)
print(type(c))

Вывод:

10.0
<class 'float'>
10
<class 'int'>
(10+0j)
<class 'complex'>
(10.55+0j)
<class 'complex'>