理论与实践

数据输入输出

任务

条件语句

任务

for循环

任务

字符串

任务

while循环

任务

列表

任务

二维数组

任务

字典

任务

集合

任务

函数与递归

任务

课程 4. Lines

难度：

任务«营销公司»

💻 Python

假设你在一家大型体育公司担任初级营销人员。你的品牌最近收购了另一家不太知名的公司。你的任务——紧急更新所有旧广告文案，将旧品牌的提及替换为新品牌“Adidas”。为了避免手动操作并减少错误，你决定编写一个小程序。

任务： & nbsp; 编写一个程序，接收两个字符串作为输入：首先是广告文案，然后是需要替换的品牌名称。程序应将文本中所有该品牌的提及替换为单词“adidas”，并在屏幕上显示更新后的文本。

重要条件： 品牌名称可以出现在句子的任何位置，并且其后可能跟有标点符号（例如句号、逗号或感叹号）。你的程序应正确处理此类情况，替换品牌名称，但保留标点符号在原位。

输入格式

第一行：广告文本（字符串）。
第二行：要替换的品牌名称。

输出格式

一行：修改后的文本，其中所有对旧品牌的引用都被替换为 "adidas"（字符串）。

示例

输入

购买NewBalance运动鞋！最好的鞋子就是NewBalance。
NewBalance

输出

购买阿迪达斯运动鞋！最好的鞋子是阿迪达斯。

提示

methods for working with strings in python

Python provides many built-in methods for working with strings. These are powerful tools that make it easy to manipulate text data. All methods are called with a dot after the variable in which the string is stored, according to the variable scheme.method().

It is important to remember that strings in Python are immutable. This means that none of the methods changes the original string. Instead, they return a new string with the changes applied.

Basic methods for working with strings

1. upper() and lower()

Convert all characters of the string to upper or lower case, respectively.

string = "Hello, World!"
print(string.upper()) # Output: HELLO, WORLD!
print(string.lower()) # Output: hello, world!
print(string) # Output: Hello, World! (the original line has not changed)

A useful tip: These methods are indispensable when you need to compare case-insensitive strings. For example, when checking user input.

user_input = "Yes"
if user_input.lower() =="yes":
print("The user agrees.")

2. strip(), lstrip() and rstrip()

Remove whitespace characters (spaces, tabs, line breaks) from the beginning and end of the line. lstrip() deletes only on the left, and rstrip() deletes only on the right.

string = "  Hello, World!  "
print(string.strip()) # Output: Hello, World!
print(string.lstrip()) # Output: Hello, World!  
print(string.rstrip()) # Output: Hello, World!

A useful tip: These are extremely important methods for "cleaning" data obtained from files or from users, who often accidentally leave unnecessary spaces. As an argument, you can pass a string of characters that need to be deleted.

dirty_string = "!!!Hello, World!?! "
print(dirty_string.strip(" !?")) # Output: Hello, World

3. split() and join()

split() splits a string into a list of substrings using the specified separator. join() collects a string from the list items by inserting a separator string between them.

string = "Hello, World!"
words =string.split(", ")
print(words) # Output: ['Hello', 'World!']

# Reverse operation
joined_string = " | ".join(words)
print(joined_string) # Output: Hello | World!

A useful tip: split() is a standard method for parsing (parsing) data presented as a string, for example, CSV files. join() is the most efficient ("pythonic") way to assemble one large string from many small ones. It works much faster than adding strings in a loop using +.

4. find() and replace()

find() searches for the first occurrence of a substring and returns its index (position). If the substring is not found, returns -1. replace() replaces all occurrences of one substring with another.

string = "Hello, World!"
index = string.find("World")
print(index) # Output: 7

new_string = string.replace("World", "Python")
print(new_string) # Output: Hello, Python!

A useful tip: There is an analog of the find() index() method.. It does the same thing, but if the substring is not found, it raises the error ValueError. Use find() if the absence of a substring is a normal situation, and index(), if it should interrupt the execution of the program. The replace() method can also accept a third argument - the number of substitutions to be made.

5. startswith() and endswith()

They check whether the string begins or ends with a specific substring. Returns True or False.

string = "Hello, World!"
print(string.startswith("Hello")) # Output: True
print(string.endswith("World!"))   # Output: True
print(string.startswith("Bye"))    # Output: False

A useful tip: It is very convenient for quick checking of file formats (filename.endswith(".txt")) or link types (url.startswith("https")).

6. isdigit(), isalpha() and isalnum()

They check what the string consists of.

isdigit(): True if all characters are numbers.
isalpha(): True if all characters are letters.
isalnum(): True if all characters are letters or numbers.

string1 = "12345"
string2 = "Hello"
string3 = "Hello123"

print(f"'{string1}' consists of digits? {string1.isdigit()}")   # Output: True
print(f"'{string2}' consists of letters? {string2.isalpha()}")   # Output: True
print(f"'{string3}' consists of letters and numbers? {string3.isalnum()}") # Output: True
print(f"'{string2}' consists of digits? {string2.isdigit()}") # Output: False

A useful tip: These methods are ideal for validating user input before attempting to convert a string to a number or using it further in the program.

A complete guide to methods

Below is a table with a more complete list of string methods for quick reference.

Method	Purpose
`S.find(str, [start],[end])`	Search for a substring in a string. Returns the number of the first occurrence or -1.
`S.rfind(str, [start],[end])`	Search for a substring in a string. Returns the number of the last occurrence or -1.
`S.index(str, [start],[end])`	Search for a substring in a string. Returns the number of the first occurrence or causes a `ValueError`.
`S.rindex(str, [start],[end])`	Search for a substring in a string. Returns the number of the last occurrence or causes a `ValueError`.
`S.replace(template, replacement[, maxcount])`	Replace the template with a replacement. `maxcount` limits the number of substitutions.
`S.split(character)`	Splitting a line by separator.
`S.isdigit()`	Whether the string consists of numbers.
`S.isalpha()`	Whether the string consists of letters.
`S.isalnum()`	Whether the string consists of numbers or letters.
`S.islower()`	Whether the string consists of lowercase characters.
`S.isupper()`	Whether the string consists of uppercase characters.
`S.isspace()`	Whether the string consists of non-displayed characters (space, `\f`, `\n`, `\r`, `\t`, `\v`).
`S.istitle()`	Whether words in a line begin with a capital letter.
`S.upper()`	Converting a string to uppercase.
`S.lower()`	Converting a string to lowercase.
`S.startswith(str)`	Does the string S start with the template `str`.
`S.endswith(str)`	Does line S end with the `str` template.
`S.join(list)`	Assembling a line from a list separated by S.
`ord(character)`	Converts a character to its ASCII/Unicode code.
`chr(number)`	Converts the ASCII/Unicode code to a character.
`S.capitalize()`	Converts the first character of the string to uppercase, and all the others to lowercase.
`S.center(width, [fill])`	Returns a centered string with the `fill` character at the edges (space by default).
`S.count(str, [start],[end])`	Returns the number of disjoint occurrences of a substring.
`S.expandtabs([tabsize])`	Replaces the tab characters `\t` with spaces.
`S.lstrip([chars])`	Deleting specified characters (or spaces) at the beginning of a line.
`S.rstrip([chars])`	Deleting specified characters (or spaces) at the end of a line.
`S.strip([chars])`	Deleting specified characters (or spaces) at the beginning and end of a line.
`S.partition(template)`	Divides a string by the first occurrence of the separator into three parts: before, the separator itself, and after.
`S.rpartition(sep)`	Divides the string by the last occurrence of the separator into three parts: before, the separator itself, and after.
`S.swapcase()`	Converts lowercase characters to uppercase, and uppercase characters to lowercase.
`S.title()`	Translates the first letter of each word to uppercase, and all the others to lowercase.
`S.zfill(width)`	Adds zeros to the left of the string to the length `width`.
`S.ljust(width, fillchar=" ")`	Aligns the line to the left, adding the characters `fillchar` to the right.
`S.rjust(width, fillchar=" ")`	Aligns the line to the right, adding `fillchar` characters to the left.
`S.format(args, *kwargs)`	String formatting (a more modern alternative to `%`).

main.py

测试 1

测试 2

测试 3

测试 4

测试 5

测试 6

测试 7

测试 8

测试 9

测试 10

开发者解答

# Получаем исходный текст от пользователя
source_text = input()
# Получаем название бренда, который нужно заменить
old_brand = input()

# Разбиваем весь текст на отдельные слова по пробелу
words = source_text.split(' ')

# Создаем пустой список, куда будем складывать новые слова
result_words = []

# Запускаем цикл, который перебирает каждое слово из списка words
for word in words:
    # Запоминаем знак препинания, если он есть в конце слова
    punctuation = ''
    # Проверяем, что слово не пустое и последний символ - один из знаков препинания
    if word and word[-1] in '.,!?:;':
        punctuation = word[-1]  # Сохраняем этот знак
        clean_word = word[:-1]  # Убираем знак из слова для сравнения
    else:
        clean_word = word # Если знака нет, чистое слово - это само слово

    # Сравниваем "чистое" слово со старым брендом
    if clean_word == old_brand:
        # Если совпало, добавляем в наш итоговый список 'Adidas' и знак препинания
        result_words.append('Adidas' + punctuation)
    else:
        # Если не совпало, просто добавляем оригинальное слово (с его знаком препинания)
        result_words.append(word)

# Соединяем слова из списка result_words обратно в одну строку через пробел
final_text = ' '.join(result_words)

# Выводим итоговый текст на экран
print(final_text)