Магические методы: __str__, __repr__, __len__, __abs__

Найти (): Как проверить, имеет ли строка определенную подстроку в Python

Используйте Метод проверки, имеет ли строка определенную подстроку.

Метод возвращает индекс первого вхождения данного значения.

Помните, что счет индекса начинается в 0.

phrase = "This is a regular text"

print(phrase.find('This'))

print(phrase.find('regular'))

print(phrase.find('text'))

0
10
18

Если значение не найдено, он вернется Отказ

phrase = "This is a regular text"

print(phrase.find('train'))

-1

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

phrase = "This is a regular text"

#look for in 'This is', the rest of the phrase is not included
print(phrase.find('This', 0, 7))

#look for in 'This is a regular'
print(phrase.find('regular', 0, 17))

#look for in 'This is a regul'
print(phrase.find('a', 0, 15))

0
10
8

zfill (): Как добавить нули в строку в Python

Используйте Вставить нули в начале строки.

Количество нулей дается числом, прошедшим, как аргумент, минус количество символов в строке.

Слово «Beach» имеет 5 символов, что дает 27 пространства для заполнения нулями, чтобы сделать его 32, как указано в переменной

word = 'beach'
size_string = 32

word_zeros = word.zfill(size_string)

print(word)
#beach

print(word_zeros)
#000000000000000000000000000beach

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

Также обратите внимание, что если аргумент меньше, чем количество символов в строке, ничего не меняется. В приведенном ниже примере «Beach» имеет 5 символов, и мы хотим добавить нули, пока не достигнет Из 4, что означает, что нечего делать

В приведенном ниже примере «Beach» имеет 5 символов, и мы хотим добавить нули, пока не достигнет Из 4, что означает, что нечего делать.

word = 'beach'
size_string = 4

word_zeros = word.zfill(size_string)

print(word)
#beach

print(word_zeros)
#'beach'

Работа отрицательного индекса

Работоспособность отрицательного индекса продемонстрирована в таблице ниже.

	P	Y	Т	H	О	N
1	2	3	4	5
-5	-4	-3	-2	-1	-0

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

Нарезка строки с помощью отрицательного(-) индекса

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

Синтаксис для нарезки строки с помощью отрицательного индекса показан ниже:

 
 s = s 

Пример кода:

 
// Substring or slicing of a string through a negative index  
>>> s = 'PYTHON'         
>>> s  

Выход

После успешного выполнения вышеуказанного программного кода мы получили следующий результат:

Нарезка строки с помощью положительного(+) индекса

Используется для нарезки или подстроки строки с помощью положительного индекса.

Синтаксис:

 
 s = s 

Пример кода:

 
// Substring or slicing of a string through a positive index  
>>> s = 'PYTHON'         
>>> s  

Выход:

Получение всей подстроки с помощью понимания списка

Возвращает полные подстроки строки с помощью нарезки строки и понимания списка.

Пример кода:

 
// Using slicing and list comprehension of string's substring  
>>> s = 'PYTHON'         
>>> str =  ] 
for i in range(Len(s)) 
 for j in range(i + 1, Len(s) + 1) 
print(str)  

Выход:

Получение всей подстроки с помощью метода itertools.combination()

Возвращает полные подстроки строки с помощью нарезки строки и понимания списка.

Пример кода:

 
// Using slicing and itertools.combination() of string's substring  
>>> s = 'PYTHON'         
>>> str =  ] 
for i in range(Len(s)) 
 for j in range(i + 1, Len(s) + 1) 
print(str)  

Выход:

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

Создание случайной буквенно-цифровой строки из фиксированных букв и цифр

Например, предположим, что нам нужна случайно сгенерированная буквенно-цифровая строка, содержащая пять букв и четыре цифры. Нам нужно определить эти параметры в функции.

Напишем программу для генерации буквенно-цифровой строки, содержащей фиксированное количество букв и цифр.

fixedString.py

 
import random 
import string 
def random_string(letter_count, digit_count): 
    str1 = ''.join((random.choice(string.ascii_letters) for x in range(letter_count))) 
    str1 += ''.join((random.choice(string.digits) for x in range(digit_count))) 
 
    sam_list = list(str1) # it converts the string to list. 
    random.shuffle(sam_list) # It uses a random.shuffle() function to shuffle the string. 
    final_string = ''.join(sam_list) 
    return final_string 
 
# define the length of the letter is eight and digits is four 
print("Generated random string of first string is:", random_string(8, 4)) 
 
# define the length of the letter is seven and digits is five 
print("Generated random string of second string is:", random_string(7, 5)) 

Выход:

Вводная информация о строках

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

Литералы строк

Литерал — способ создания объектов, в случае строк Питон предлагает несколько основных вариантов:

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

Разницы между строками с одинарными и двойными кавычками нет — это одно и то же

Какие кавычки использовать — решать вам, соглашение PEP 8 не дает рекомендаций по использованию кавычек. Просто выберите один тип кавычек и придерживайтесь его. Однако если в стоке используются те же кавычки, что и в литерале строки, используйте разные типы кавычек — обратная косая черта в строке ухудшает читаемость кода.

Кодировка строк

В третьей версии языка программирования Python все строки представляют собой последовательность Unicode-символов.

В Python 3 кодировка по умолчанию исходного кода — UTF-8. Во второй версии по умолчанию использовалась ASCII. Если необходимо использовать другую кодировку, можно разместить специальное объявление на первой строке файла, к примеру:

Максимальная длина строки в Python

Максимальная длина строки зависит от платформы. Обычно это:

• 2**31 — 1 — для 32-битной платформы;
• 2**63 — 1 — для 64-битной платформы;

Константа , определенная в модуле

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

Одна из самых распространенных операций со строками — их объединение (конкатенация). Для этого используется знак , в результате к концу первой строки будет дописана вторая:

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

Сравнение строк

При сравнении нескольких строк рассматриваются отдельные символы и их регистр:

• цифра условно меньше, чем любая буква из алфавита;
• алфавитная буква в верхнем регистре меньше, чем буква в нижнем регистре;
• чем раньше буква в алфавите, тем она меньше;

При этом сравниваются по очереди первые символы, затем — 2-е и так далее.

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

Как удалить строку в Python

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

Или перезаписать переменную пустой строкой:

Обращение по индексу

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

Индекс начинается с 0

В Python предусмотрена возможность получить доступ и по отрицательному индексу. В таком случае отсчет будет вестись от конца строки:

Присоединяйтесь к (): Как присоединиться к элементам элементами для одной строки в Python

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

Основной синтаксис:

Согласно синтаксису выше, строка требуется в качестве сепаратора.

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

Так как Способ принимает только строки, если какой-либо элемент в Iterable имеет другой тип, ошибка будет брошена.

Давайте посмотрим некоторые примеры с: строка, список, кортеж, набор и словарь

Присоединиться (): строки

Метод ставит Знак как сепаратор для каждого символа в строке.

my_string = 'beach'

print('$'.join(my_string))
#output: b$e$a$c$h

Присоединяйтесь (): списки

У меня простой список трех предметов, представляющих автомобильные бренды.

Метод будет использовать Знак как сепаратор.

Он объединяет все предметы в списке и ставит знак между ними.

my_list = 

print('$'.join(my_list))
#output: bmw$ferrari$mclaren

Этот пример напоминает вам, что не работает со строковыми элементами.

При попытке объединить Элементы, ошибка поднимается.

my_list = 

print('$'.join(my_list))
#output:
#Traceback (most recent call last):
#  File "", line 1, in 
#TypeError: sequence item 0: expected str instance, int found

Присоединиться (): кортежи

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

Опять же, я использую Знак как сепаратор.

my_tuple = ('bmw', 'ferrari', 'mclaren')

print('$'.join(my_tuple))
#output: bmw$ferrari$mclaren

Присоединиться (): наборы

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

my_set = {'bmw', 'ferrari', 'mclaren'}
print('|'.join(my_set))
#output: ferrari|bmw|mclaren

Присоединиться (): словари

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

В этом примере показано конконтрация клавиш.

my_dict = {'bmw': 'BMW I8', 'ferrari': 'Ferrari F8', 'mclaren': 'McLaren 720S'}

print(','.join(my_dict))
#output: bmw,ferrari,mclaren

Использование random.choice()

Функция random.choice() используется в строке Python для генерации последовательности символов и цифр, которые могут повторять строку в любом порядке.

Создадим программу для генерации случайной строки с помощью функции random.choices().

Random_str.py

 
import string   
import random # define the random module 
S = 10  # number of characters in the string. 
# call random.choices() string module to find the string in Uppercase + numeric data. 
ran = ''.join(random.choices(string.ascii_uppercase + string.digits, k = S))   
print("The randomly generated string is : " + str(ran)) # print the random data 

Выход:

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

Методы	Описание
String.ascii_letters	Возвращает случайную строку, содержащую как прописные, так и строчные буквы.
String_ascii_uppercase	Это метод случайной строки, который возвращает только строку в верхнем регистре.
String.ascii_lowercase	Метод случайной строки, который возвращает строку только в нижнем регистре.
String.digits	Возвращает строку с числовыми символами.
String.punctuation	Метод, возвращающий строку с символами пунктуации.

Сгенерировать случайную строку из прописных и строчных букв:

UprLwr.py

 
# write a program to generate the random string in upper and lower case letters. 
import random 
import string 
def Upper_Lower_string(length): # define the function and pass the length as argument 
    # Print the string in Lowercase 
    result = ''.join((random.choice(string.ascii_lowercase) for x in range(length))) # run loop until the define length 
    print(" Random string generated in Lowercase: ", result) 
 
    # Print the string in Uppercase 
    result1 = ''.join((random.choice(string.ascii_uppercase) for x in range(length))) # run the loop until the define length 
    print(" Random string generated in Uppercase: ", result1) 
 
Upper_Lower_string(10) # define the length 

Выход:

Случайная строка указанных символов:

Specific.py

 
# create a program to generate the random string of given letters. 
import random 
import string 
def specific_string(length): 
    sample_string = 'pqrstuvwxy' # define the specific string 
    # define the condition for random string 
    result = ''.join((random.choice(sample_string)) for x in range(length)) 
    print(" Randomly generated string is: ", result) 
 
specific_string(8) # define the length 
specific_string(10) 

Выход:

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

БезRepeat.py

 
# create a program to generate a string with or without repeating the characters. 
import random 
import string 
print("Use of random.choice() method") 
def specific_string(length): 
    
    letters = string.ascii_lowercase # define the lower case string 
     # define the condition for random.choice() method 
    result = ''.join((random.choice(letters)) for x in range(length)) 
    print(" Random generated string with repetition: ", result) 
 
specific_string(8) # define the length 
specific_string(10) 
 
 
print("") # print the space 
print("Use of random.sample() method") 
def WithoutRepeat(length): 
    letters = string.ascii_lowercase # define the specific string 
    # define the condition for random.sample() method 
    result1 = ''.join((random.sample(letters, length)))  
    print(" Random generated string without repetition: ", result1) 
 
WithoutRepeat(8) # define the length 
WithoutRepeat(10)  

Выход:

Как видно из вышеприведенного вывода, метод random.sample() возвращает строку, в которой все символы уникальны и не повторяются. В то время как метод random.choice() возвращает строку, которая может содержать повторяющиеся символы. Итак, можно сказать, что если мы хотим сгенерировать уникальную случайную строку, нужно использовать метод random.sample().

Строковые операторы

Оператор	Описание
+	Он известен как оператор конкатенации, используемый для соединения строк по обе стороны от оператора.
*	Известен как оператор повторения. Он объединяет несколько копий одной и той же строки.
[]	оператор среза. Он используется для доступа к подстрокам определенной строки.
	оператор среза диапазона, используется для доступа к символам из указанного диапазона.
in	Оператор членства. Он возвращается, если в указанной строке присутствует определенная подстрока.
not in	Также является оператором членства и выполняет функцию, обратную in. Он возвращает истину, если в указанной строке отсутствует конкретная подстрока.
r / R	Используется для указания необработанной строки. Необработанные строки применяются в тех случаях, когда нам нужно вывести фактическое значение escape-символов, таких как «C: // python». Чтобы определить любую строку как необработанную, за символом r или R следует строка.
%	Необходим для форматирования строк. Применяет спецификаторы формата, используемые в программировании на C, такие как %d или %f, для сопоставления их значений в python. Мы еще обсудим, как выполняется форматирование в Python.

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

 
str = "Hello"    
str1 = " world"   
print(str*3) # prints HelloHelloHello   
print(str+str1)# prints Hello world    
print(str) # prints o               
print(str); # prints ll                   
print('w' in str) # prints false as w is not present in str   
print('wo' not in str1) # prints false as wo is present in str1.    
print(r'C://python37') # prints C://python37 as it is written   
print("The string str : %s"%(str)) # prints The string str : Hello    

Выход:

HelloHelloHello 
Hello world 
o 
ll 
False 
False 
C://python37 
The string str : Hello 

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

Напишем программу для печати безопасных случайных строк с использованием различных методов secrets.choice().

Secret.py

 
# write a program to display the different random string method using the secrets.choice(). 
# imports necessary packages 
import random  
import string 
import secrets 
num = 10 # define the length of the string 
# define the secrets.choice() method and pass the string.ascii_letters + string.digits as an parameters. 
res = ''.join(secrets.choice(string.ascii_letters + string.digits) for x in range(num)) 
# Print the Secure string with the combination of ascii letters and digits 
print("Secure random string is :"+ str(res)) 
 
res = ''.join(secrets.choice(string.ascii_letters) for x in range(num)) 
# Print the Secure string with the combination of ascii letters  
print("Secure random string is :"+ str(res)) 
 
res = ''.join(secrets.choice(string.ascii_uppercase) for x in range(num)) 
# Print the Secure string in Uppercase 
print("Secure random string is :"+ str(res)) 
 
res = ''.join(secrets.choice(string.ascii_lowercase) for x in range(num)) 
# Print the Secure string in Lowercase 
print("Secure random string is :"+ str(res)) 
 
res = ''.join(secrets.choice(string.ascii_letters + string.punctuation) for x in range(num)) 
# Print the Secure string with the combination of letters and punctuation 
print("Secure random string is :"+ str(res)) 
 
res = ''.join(secrets.choice(string.digits) for x in range(num)) 
# Print the Secure string using string.digits 
print("Secure random string is :"+ str(res)) 
 
res = ''.join(secrets.choice(string.ascii_letters + string.digits + string.punctuation) for x in range(num)) 
# Print the Secure string with the combonation of letters, digits and punctuation  
print("Secure random string is :"+ str(res)) 

Выход:

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

Как перевернуть строку в Python с помощью рекурсии

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

Рекурсия – это мощный инструмент в программировании. Рекурсивная функция вызывает себя несколько раз, пока не будет достигнут базовый вариант.

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

Давайте перефразируем это определение простым языком.

Рекурсия простыми словами

Предположим, вы создали функцию для решения какой-то проблемы. Функция разработана таким образом, что каждый раз при вызове она вызывает сама себя снова и снова. Это называется рекурсивными вызовами функции.

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

Скачивайте книгу у нас в телеграм

Скачать

×

Как использовать рекурсию для реверсирования строк

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

Итак, наша задача – перевернуть строку .

Давайте на время забудем о рекурсии и начнем с того, что мы уже знаем.

Первая буква исходной строки будет последней буквой в перевернутой строке, верно? Так что давайте вытащим первую букву – в данном случае – и поставим её в самый конец.

Теперь у нас осталась строка . И проблема свелась к переворачиванию данной подстроки (поскольку уже находится в нужном месте).

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

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

Сделаем это еще пару раз – вытащим сначала , а затем и .

Теперь у вас осталось перевернуть – пустую строку.

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

Что мы здесь сделали?

1. На каждом шаге мы выполняли одну и ту же задачу – вытаскивали первую букву из каждой последующей подстроки.
2. И уменьшали исходную задачу до переворота строки, которая на одну букву короче, чем была раньше.

Когда мы остановились?

Когда строка стала пустой – не осталось букв, которые нужно было вытаскивать.

На иллюстрации ниже показано, что мы сделали:

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

Рекурсия для реверсирования строк

Давайте напишем функцию , которая делает именно то, что мы сделали выше. Функция принимает и возвращает перевернутую копию .

def reverseString(any_string):
    if any_string == "":
        return any_string
    else:
        return reverseString(any_string) + any_string

Давайте разберем, как работает рекурсия, когда вы вызываете функцию .

reverseString("code")

# Output
# 'edoc'

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

Это объясняется на изображении ниже:

Вы знаете, что, когда выполняется вызов функции с аргументом , функция возвращает в сочетании с .

Следующий вызов возвращает , а следующий – . И дальше, наконец-то, мы получаем – желаемую перевернутую строку.

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

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

reverseString("Python")

# Output:
# nohtyP

reverseString("Python Reverse String")

# Output:
# gnirtS esreveR nohtyP

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

От редакции Pythonist. Рекомендуем статью «Примеры программ с использованием рекурсии на языке Python».

В следующих двух разделах мы рассмотрим более простые способы переворачивания строк. Итак, поехали!

Числовые литералы

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

Int(числа с целым знаком)	Long(длинные целые числа)	float(с плавающей запятой)	Complex(сложные)
Числа(могут быть как положительными, так и отрицательными) без дробной части, например: 100	Целые числа неограниченного размера, за которыми следует строчная или прописная буква L, например: 87032845L	Действительные числа с целой и дробной частью, например: -26,2	В форме a + bj, где a – действительная часть, а b – мнимая часть комплексного числа. например: 3.14j

Пример числовых литералов:

x = 0b10100 #Binary Literals
y = 100 #Decimal Literal 
z = 0o215 #Octal Literal
u = 0x12d #Hexadecimal Literal

#Float Literal
float_1 = 100.5 
float_2 = 1.5e2

#Complex Literal 
a = 5+3.14j

print(x, y, z, u)
print(float_1, float_2)
print(a, a.imag, a.real)

Выход:

20 100 141 301
100.5 150.0(5+3.14j) 3.14 5.0

Оглавление

1. Основы строки Python
2. Как разделить строку в Python
3. Как удалить все белые пробелы в строке в Python
4. Как обрабатывать многослойные строки в Python
5. lstrip (): как удалить пробелы и символы с начала строки в Python
6. RSTRIP (): Как удалить пробелы и символы с конца строки в Python
7. Стрип (): как удалить пробелы и символы с начала и конца строки в Python
8. Как сделать целый ряд строчной буквы в Python
9. Как сделать целый строковый прописными буквами в Python
10. Как использовать титульный случай в Python
11. Как использовать чехол Swap в Python
12. Как проверить, пустая строка в Python
13. Rjust (): как правильно озвучить строку в Python
14. Ljust (): как оставить – обосновать строку в Python
15. Isalnum (): Как проверить буквенно-цифровые символы только в строке в Python
16. ISPRINTABLE (): Как проверить для печатных игр в строке в Python
17. ISSPACE (): Как проверить белое пространство только в строке в Python
18. StartSwith (): Как проверить, начинается ли строка с определенного значения в Python
19. Capitalize (): Как установить первый персонаж только в верхний регистр в строке в Python
20. Isupper (): Как проверить на верхний регистр только в строке в Python
21. Присоединяйтесь к (): Как присоединиться к элементам элементами для одной строки в Python
22. Сплитлины (): Как разделить строку на перерывах линии в Python
23. islower (): Как проверить на нижний регистр только в строке в Python
24. ISNUMERIC (): Как проверить числовые численности только в строке в Python
25. ISDIGIT (): Как проверить цифры только в строке в Python
26. Isdecimal (): Как проверить десятичные дроби только в строке в Python
27. ISALPHA (): Как проверить буквы только в строке в Python
28. Istitle (): Как проверить, начинается ли каждое слово с верхнего регистра в строке в Python
29. ExpandTabs (): Как установить количество пробелов для вкладки в строке в Python
30. Центр (): Как центрировать строку в Python
31. zfill (): Как добавить нули в строку в Python
32. Найти (): Как проверить, имеет ли строка определенную подстроку в Python
33. Как удалить префикс или суффикс в строке в Python
34. lstrip () vs readleprefix () и rstrip () vs removeuffix ()
35. Как нарезка работает в Python
36. Как изменить строку в Python
37. Заключение

Магические методы __str__ и __repr__

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

• __str__() – магический
  метод для отображения информации об объекте класса для пользователей (например,
  для функций print, str);

• __repr__() – магический
  метод для отображения информации об объекте класса в режиме отладки (для
  разработчиков).

Чтобы лучше
понять, как работают эти методы, объявим класс для описания кошек:

class Cat:
    def __init__(self, name):
        self.name = name

Если теперь перейти
в консоль Python, импортировать
этот класс из нашего текущего модуля ex1:

from ex1 import Cat

и создать его
экземпляр:

cat = Cat('Васька')

то при выводе cat, увидим
служебную информацию:

<ex1.Cat object at 0x0495D028>

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

    def __repr__(self):
        return f"{self.__class__}: {self.name}"

Обратите
внимание, этот метод должен возвращать строку, поэтому здесь записан оператор return и формируемая
строка. Что именно возвращать, мы решаем сами, в данном случае – это название
класса и имя кошки

Перезапустим
консоль и снова импортируем измененный класс Cat. И, смотрите,
теперь при создании экземпляра мы видим другую информацию при его выводе:

<class
‘ex1.Cat’>: Васька

Как раз то, что
определили в магическом методе __repr__. То же самое увидим и при
использовании функции print и str. По идее, здесь
должен отрабатывать другой магический метод __str__, но так как
он у нас еще не переопределен, то автоматически выполняется метод __repr__.

Давайте добавим
второй магический метод __str__ и посмотрим, как это повлияет на
отображение данных:

    def __str__(self):
        return f"{self.name}"

cat

по-прежнему
будем видеть служебную информацию от метода __repr__.  Однако,
если выполнить отображение экземпляра класса через print или str, то будет
срабатывать уже второй метод __str__. Вот в этом отличие этих двух
магических методов.