django33全栈班2025年011 字符串和大量练习题

前言

到目前为止，我们已经顺利完成了 Python 基础语法的学习之旅啦 接下来，我们将开启一段新的学习征程，那就是对常用数据结构进行进阶式的学习和使用哦。在众多数据结构中，我们将主要聚焦于字符串、列表和字典这三种非常重要的数据结构呢 而在本节课，我们将率先踏入字符串的奇妙世界，一起探索它的各种高级用法和技巧。让我们跟随课程的节奏，深入挖掘字符串的潜力，开启一场精彩的学习体验，为我们的 Python 编程技能添砖加瓦，为后续解决更复杂的编程问题做好充分的准备吧 希望大家都能积极参与，认真学习，在这堂课中收获满满哦

字符串的常用内置方法

一、大小写转换

• str.upper()：

  s = "hello world"
  upper_s = s.upper()
  print(upper_s)  # 输出: HELLO WORLD
  

  该方法将字符串中的所有字符转换为大写形式。它不会修改原始字符串，而是返回一个新的字符串。

• str.lower()：

  s = "HELLO WORLD"
  lower_s = s.lower()
  print(lower_s)  # 输出: hello world
  

  与 upper() 相反，将字符串中的所有字符转换为小写形式，同样不修改原始字符串，而是返回新字符串。

• str.capitalize()：

  s = "hello world"
  capitalized_s = s.capitalize()
  print(capitalized_s)  # 输出: Hello world
  

  将字符串的第一个字符转换为大写，其余字符为小写。

• str.title()：

  s = "hello world"
  titled_s = s.title()
  print(titled_s)  # 输出: Hello World
  

  将字符串中每个单词的首字母大写，其余字母小写。

二、查找与替换

• str.find(substring)：

  s = "hello world"
  index = s.find("world")
  print(index)  # 输出: 6
  

  查找子字符串 substring 在原字符串中的首次出现位置，返回其索引，如果未找到则返回 -1。

• str.rfind(substring)：

  s = "hello world world"
  index = s.rfind("world")
  print(index)  # 输出: 12
  

  与 find() 类似，但从字符串的末尾开始查找子字符串的最后一次出现位置，未找到时返回 -1。

• str.replace(old, new)：

  s = "hello world"
  new_s = s.replace("world", "python")
  print(new_s)  # 输出: hello python
  

  将字符串中所有的 old 子字符串替换为 new 子字符串，返回一个新字符串，原始字符串不变。

三、字符串的分割与拼接

• str.split(separator)：

  s = "hello,world,python"
  parts = s.split(",")
  print(parts)  # 输出: ['hello', 'world', 'python']
  

  根据 separator 将字符串分割为多个子字符串，并存储在列表中。如果不提供 separator，默认使用空格分割。

• str.join(iterable)：

  parts = ["hello", "world", "python"]
  s = ",".join(parts)
  print(s)  # 输出: hello,world,python
  

  使用原字符串作为分隔符，将可迭代对象中的元素拼接成一个新字符串。

四、字符串的长度和检查

• len(str)：

  s = "hello world"
  length = len(s)
  print(length)  # 输出: 11
  

  这是一个内置函数，用于计算字符串的长度，返回字符的数量。

• str.startswith(prefix)：

  s = "hello world"
  result = s.startswith("hello")
  print(result)  # 输出: True
  

  检查字符串是否以 prefix 开头，返回布尔值。

• str.endswith(suffix)：

  s = "hello world"
  result = s.endswith("world")
  print(result)  # 输出: True
  

  检查字符串是否以 suffix 结尾，返回布尔值。

五、去除空格和特殊字符

• str.strip()：

  s = "   hello world   "
  stripped_s = s.strip()
  print(stripped_s)  # 输出: hello world
  

  去除字符串前后的空格（默认）或指定的字符序列。

• str.lstrip()：

  s = "   hello world"
  left_stripped_s = s.lstrip()
  print(left_stripped_s)  # 输出: hello world
  

  仅去除字符串左边的空格或指定字符序列。

• str.rstrip()：

  s = "hello world   "
  right_stripped_s = s.rstrip()
  print(right_stripped_s)  # 输出: hello world
  

  仅去除字符串右边的空格或指定字符序列。

六、字符串的判断和统计

• str.isalpha()：

  s1 = "hello"
  s2 = "hello123"
  print(s1.isalpha())  # 输出: True
  print(s2.isalpha())  # 输出: False
  

  判断字符串是否只包含字母，返回布尔值。

• str.isdigit()：

  s1 = "123"
  s2 = "hello123"
  print(s1.isdigit())  # 输出: True
  print(s2.isdigit())  # 输出: False
  

  判断字符串是否只包含数字，返回布尔值。

• str.count(substring)：

  s = "hello world"
  count = s.count("l")
  print(count)  # 输出: 3
  

  统计子字符串 substring 在原字符串中出现的次数。

七、字符串的编码和解码

• str.encode(encoding='utf-8')：

  s = "hello world"
  encoded_s = s.encode('utf-8')
  print(encoded_s)  # 输出: b'hello world'
  

  将字符串编码为字节串，默认为 utf-8 编码，常用于文件存储和网络传输。

• bytes.decode(encoding='utf-8')：

  encoded_s = b'hello world'
  decoded_s = encoded_s.decode('utf-8')
  print(decoded_s)  # 输出: hello world
  

  将字节串解码为字符串，需要使用与编码时相同的编码方式。

八、格式化字符串

• str.format()：

  name = "Alice"
  age = 25
  s = "My name is {} and I am {} years old.".format(name, age)
  print(s)  # 输出: My name is Alice and I am 25 years old.
  

  使用 {} 占位符，将 format() 方法中的参数按顺序填入占位符中。

• f-strings（格式化字符串字面值）：

  name = "Alice"
  age = 25
  s = f"My name is {name} and I am {age} years old."
  print(s)  # 输出: My name is Alice and I am 25 years old.
  

  在字符串前加 f，可以直接在 {} 中插入变量或表达式，简洁直观。

字符串的切片

在 Python 中，字符串切片是一种强大且常用的操作，允许你从字符串中提取出部分字符序列。它使用方括号 [] 并通过 start:end:step 的形式来指定切片的范围和步长。以下是对切片操作的详细解释：

基本语法

string[start:end:step]

• start：切片开始的索引（包含该索引位置的字符）。
• end：切片结束的索引（不包含该索引位置的字符）。
• step：切片的步长，即每隔几个字符取一个字符。

示例代码及解释：

s = "Hello, World!"

# 提取从索引 0 到索引 5 的字符
print(s[0:5])  # 输出: Hello

# 提取从索引 7 到末尾的字符
print(s[7:])  # 输出: World!

# 提取从开头到索引 5 的字符
print(s[:5])  # 输出: Hello

# 提取整个字符串
print(s[:])  # 输出: Hello, World!

# 从索引 0 开始，每隔 2 个字符提取一个字符
print(s[0::2])  # 输出: Hlo ol!

# 从索引 7 开始，到索引 12，每隔 3 个字符提取一个字符
print(s[7:12:3])  # 输出: Wl

# 反转字符串
print(s[::-1])  # 输出:!dlroW,olleH

使用切片的一些特殊情况和细节

1. 省略 start 或 end 时的默认值：

   • 当 start 被省略时，默认为 0，即从字符串的开头开始切片。
   • 当 end 被省略时，默认为字符串的长度，即切片到字符串的末尾。

2. 负索引的使用：

   • 可以使用负索引，其中 -1 表示字符串的最后一个字符，-2 表示倒数第二个字符，依此类推。

   s = "Hello, World!"
   # 提取最后 6 个字符
   print(s[-6:])  # 输出: World!
   # 从倒数第 8 个字符到倒数第 3 个字符
   print(s[-8:-3])  # 输出: o, Wo
   

3. 步长为负数：

   • 当 step 为负数时，切片将从右向左进行，常用于反转字符串。

   s = "Hello, World!"
   # 从右向左，每隔 1 个字符提取一个字符
   print(s[::-1])  # 输出:!dlroW,olleH
   

切片的实际应用场景

1. 截取子串：

   • 从较长的字符串中截取所需的部分。例如，从文件路径中提取文件名或文件扩展名。

   file_path = "/path/to/your/file.txt"
   file_name = file_path[file_path.rfind('/') + 1:]
   print(file_name)  # 输出: file.txt
   

2. 提取特定位置的元素：

   • 从字符串中提取特定位置的元素，例如提取日期中的年、月、日。

   date = "2025-01-02"
   year = date[0:4]
   month = date[5:7]
   day = date[8:]
   print(year, month, day)  # 输出: 2025 01 02
   

3. 字符串的跳跃式提取：

   • 根据一定的间隔提取字符，比如从字符串中提取偶数位置的字符。

   s = "abcdefghijklmn"
   even_chars = s[1::2]
   print(even_chars)  # 输出: bdfhjln
   

注意事项：

• 切片操作不会修改原始字符串，而是返回一个新的字符串。
• 切片时，如果 start 或 end 超出字符串的范围，Python 不会抛出错误，而是会自动调整到字符串的边界。

通过使用字符串切片，你可以灵活地处理各种字符串操作，从简单的截取到复杂的字符串重组和提取，它为处理字符串数据提供了极大的便利和灵活性。无论是数据处理、文本分析还是文本格式转换，字符串切片都是一个非常实用的工具。

课堂练习

练习一：字符串反转

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串，然后使用字符串切片将其反转并输出结果。

分析： 本题主要考查学生对字符串切片中步长为负数的使用，以及 pywebio3 的输入输出功能。学生需要掌握如何使用切片操作实现字符串的反转，同时使用 pywebio3 接收用户输入并展示结果。

参考代码：

from pywebio3.input import input as pw_input
from pywebio3.output import put_text


def reverse_string():
    # 获取用户输入的字符串
    original_string = pw_input("请输入一个字符串：")
    reversed_string = original_string[::-1]
    put_text(f"反转后的字符串是：{reversed_string}")


if __name__ == "__main__":
    reverse_string()

代码解释：

1. 首先，使用 pw_input 函数从用户那里获取一个字符串，并将其存储在 original_string 变量中。
2. 然后，使用切片操作 [::-1] 对 original_string 进行反转，将结果存储在 reversed_string 变量中。这里 [::-1] 表示从字符串的最后一个字符开始，以步长为 -1（即从右向左）进行切片，实现字符串的反转。
3. 最后，使用 put_text 函数将反转后的字符串输出给用户。

点评： 这是一个简单的练习，旨在让学生熟悉 pywebio3 的输入输出功能和字符串切片的基本操作。通过这个练习，学生可以快速掌握如何使用切片实现字符串的反转，为后续更复杂的操作打下基础。

练习二：提取子串

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串和两个索引（开始索引和结束索引），使用字符串切片提取并输出从开始索引到结束索引的子串。

分析： 本题涉及到对字符串切片中 start 和 end 索引的使用，以及如何通过 pywebio3 接收多个用户输入。学生需要理解切片的 start:end 语法，并能正确处理用户输入的索引，确保程序的健壮性。

参考代码：

from pywebio3.input import input_group, input
from pywebio3.output import put_text


def extract_substring():
    # 获取用户输入的字符串和索引
    data = input_group("请输入一个字符串和开始、结束索引", [
        input(name='string',),
        input(name='start_index', type='number'),
        input(name='end_index', type='number')
    ])
    original_string = data['string']
    start_index = int(data['start_index'])
    end_index = int(data['end_index'])
    sub_string = original_string[start_index:end_index]
    put_text(f"提取的子串是：{sub_string}")


if __name__ == "__main__":
    extract_substring()

代码解释：

1. 使用 input_group 函数创建一个输入组，让用户输入字符串和两个索引。使用 input 函数接收用户输入的字符串和两个数字类型的索引，并将它们存储在 data 字典中。
2. 将 start_index 和 end_index 从字符串转换为整数，存储在相应的变量中。
3. 使用切片操作 original_string[start_index:end_index] 从 original_string 中提取子串，存储在 sub_string 变量中。
4. 最后，使用 put_text 函数输出提取的子串。

点评： 这个练习让学生深入理解字符串切片的 start:end 操作，同时加强对 pywebio3 输入组和输入类型转换的掌握。学生需要注意输入的索引范围，避免越界问题，这有助于培养他们对输入数据的处理能力。

练习三：字符串替换

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串和两个子串（需要替换的子串和替换后的子串），使用字符串的 replace 方法替换子串并输出结果。

分析： 本题主要考查学生对字符串内置方法 replace 的使用，以及 pywebio3 的交互功能。学生需要知道如何调用 replace 方法替换字符串中的子串，并使用 pywebio3 进行用户交互。

参考代码：

from pywebio3.input import input_group, input
from pywebio3.output import put_text


def replace_substring():
    # 获取用户输入的字符串和子串
    data = input_group("请输入一个字符串、要替换的子串和替换后的子串", [
        input(name='string',),
        input(name='old_substring',),
        input(name='new_substring',)
    ])
    original_string = data['string']
    old_substring = data['old_substring']
    new_substring = data['new_substring']
    replaced_string = original_string.replace(old_substring, new_substring)
    put_text(f"替换后的字符串是：{replaced_string}")


if __name__ == "__main__":
    replace_substring()

代码解释：

1. 使用 input_group 函数让用户输入原始字符串、要替换的子串和替换后的子串，存储在 data 字典中。
2. 从 data 字典中提取相应的字符串和子串，并存储在变量中。
3. 调用 original_string.replace(old_substring, new_substring) 方法将 original_string 中的 old_substring 替换为 new_substring，结果存储在 replaced_string 中。
4. 使用 put_text 函数输出替换后的字符串。

点评： 此练习帮助学生熟悉字符串的 replace 方法，让他们学会使用内置方法修改字符串的内容，同时利用 pywebio3 实现用户交互，提高学生对字符串处理和用户界面的综合运用能力。

练习四：统计字符出现次数

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串和一个字符，使用循环和条件语句统计该字符在字符串中出现的次数并输出结果。

分析： 本题结合了字符串遍历、条件判断和 pywebio3 的使用。学生需要使用 for 循环遍历字符串中的每个字符，使用条件语句检查是否为目标字符，并进行计数。

参考代码：

from pywebio3.input import input_group, input
from pywebio3.output import put_text


def count_character():
    # 获取用户输入的字符串和字符
    data = input_group("请输入一个字符串和一个字符", [
        input(name='string',),
        input(name='character',)
    ])
    original_string = data['string']
    target_character = data['character']
    count = 0
    for char in original_string:
        if char == target_character:
            count += 1
    put_text(f"字符 '{target_character}' 在字符串中出现的次数是：{count}")


if __name__ == "__main__":
    count_character()

代码解释：

1. 使用 input_group 函数获取用户输入的字符串和字符，存储在 data 字典中。
2. 初始化 count 变量为 0，用于统计字符出现的次数。
3. 使用 for 循环遍历 original_string 中的每个字符，对于每个字符，使用 if 语句判断是否为 target_character，若是则将 count 加 1。
4. 最后使用 put_text 函数输出统计结果。

点评： 此练习综合了字符串遍历和条件判断，让学生巩固 for 循环和 if 语句的使用，同时结合 pywebio3 进行输入输出，有助于学生掌握字符串的基本处理和计数逻辑。

练习五：检查字符串是否为回文

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串，使用字符串切片和比较操作检查该字符串是否为回文，并输出结果。

分析： 本题要求学生运用字符串切片和比较操作，以及 pywebio3 的交互功能。学生需要知道如何使用切片操作反转字符串，并将其与原始字符串比较来判断是否为回文。

参考代码：

from pywebio3.input import input as pw_input
from pywebio3.output import put_text


def check_palindrome():
    # 获取用户输入的字符串
    original_string = pw_input("请输入一个字符串：")
    reversed_string = original_string[::-1]
    if original_string == reversed_string:
        put_text(f"字符串 '{original_string}' 是回文。")
    else:
        put_text(f"字符串 '{original_string}' 不是回文。")


if __name__ == "__main__":
    check_palindrome()

代码解释：

1. 使用 pw_input 函数获取用户输入的字符串，并存储在 original_string 中。
2. 使用切片操作 [::-1] 反转字符串，将结果存储在 reversed_string 中。
3. 使用 if 语句比较 original_string 和 reversed_string 是否相等，根据结果输出相应信息。

点评： 这个练习进一步巩固了字符串切片的使用，并结合了逻辑判断，同时通过 pywebio3 实现用户交互，让学生学会判断字符串是否为回文，增强他们对字符串处理和逻辑判断的综合运用能力。

通过这些练习，学生可以在实践中更好地掌握 pywebio3 与字符串相关知识的结合，提高字符串处理的编程能力，同时也加强了用户交互和逻辑判断的能力，为后续的编程学习打下坚实的基础。

课后练习

练习一：提取特定前缀和后缀的子串

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串、一个前缀和一个后缀。程序需要找出字符串中以该前缀开始且以该后缀结束的子串，并输出结果。

分析： 本题需要综合运用字符串的查找方法和切片操作。学生需要先找到前缀和后缀的位置，然后根据位置使用切片提取子串。同时，需要考虑前缀和后缀可能不存在的情况。

参考代码：

from pywebio3.input import input_group, input
from pywebio3.output import put_text


def extract_substring_by_prefix_and_suffix():
    # 获取用户输入的字符串、前缀和后缀
    data = input_group("请输入一个字符串、前缀和后缀", [
        input(name='string',),
        input(name='prefix',),
        input(name='suffix',)
    ])
    original_string = data['string']
    prefix = data['prefix']
    suffix = data['suffix']
    start_index = original_string.find(prefix)
    if start_index == -1:
        put_text("前缀不存在于字符串中。")
        return
    end_index = original_string.rfind(suffix)
    if end_index == -1:
        put_text("后缀不存在于字符串中。")
        return
    end_index = end_index + len(suffix)
    sub_string = original_string[start_index:end_index]
    put_text(f"提取的子串是：{sub_string}")


if __name__ == "__main__":
    extract_substring_by_prefix_and_suffix()

代码解释：

1. 使用 input_group 函数让用户输入字符串、前缀和后缀，将输入存储在 data 字典中。
2. 使用 find 方法查找前缀的起始位置，如果前缀不存在（返回 -1），输出相应信息并返回。
3. 使用 rfind 方法查找后缀的起始位置，如果后缀不存在（返回 -1），输出相应信息并返回。
4. 计算后缀的结束位置，将后缀的起始位置加上后缀的长度。
5. 使用切片从前缀开始位置到后缀结束位置提取子串，并输出结果。

点评： 本题涉及到 find 和 rfind 方法的使用，以及对可能不存在的前缀和后缀的处理，让学生掌握在实际问题中灵活运用字符串查找和切片的能力，同时利用 pywebio3 进行用户交互和结果输出，加强对字符串操作的综合运用。

练习二：字符串中的数字提取与求和

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串。程序需要提取字符串中所有的数字字符，并将它们作为整数求和，输出结果。

分析： 学生需要遍历字符串，使用 isdigit 方法找出数字字符，将其转换为整数并累加求和。同时要注意处理可能的异常情况，如字符串中没有数字字符。

参考代码：

from pywebio3.input import input as pw_input
from pywebio3.output import put_text


def sum_digits_in_string():
    # 获取用户输入的字符串
    original_string = pw_input("请输入一个字符串：")
    total_sum = 0
    num_str = ""
    for char in original_string:
        if char.isdigit():
            num_str += char
        else:
            if num_str:
                total_sum += int(num_str)
                num_str = ""
    if num_str:
        total_sum += int(num_str)
    put_text(f"字符串中数字的总和是：{total_sum}")


if __name__ == "__main__":
    sum_digits_in_string()

代码解释：

1. 使用 pw_input 函数获取用户输入的字符串，存储在 original_string 中。
2. 初始化 total_sum 为 0 用于存储数字之和，num_str 用于存储连续的数字字符。
3. 遍历字符串，若字符是数字，将其添加到 num_str 中；若不是数字且 num_str 不为空，将 num_str 转换为整数累加到 total_sum 并清空 num_str。
4. 最后处理可能剩余的数字字符，将其转换为整数并累加到 total_sum，输出结果。

点评： 本题考查了 isdigit 方法的使用和数字的提取与求和，需要学生对字符进行逐个处理和条件判断，锻炼学生对字符串元素的筛选和转换能力，同时结合 pywebio3 进行用户输入和结果输出。

练习三：交替大小写转换

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串。程序需要将字符串中的字符交替转换为大写和小写，从大写开始，并输出结果。

分析： 本题要求学生根据字符的位置进行大小写转换。可以使用 enumerate 函数获取字符的索引，根据索引的奇偶性进行大小写转换。

参考代码：

from pywebio3.input import input as pw_input
from pywebio3.output import put_text


def alternate_case_conversion():
    # 获取用户输入的字符串
    original_string = pw_input("请输入一个字符串：")
    result_string = ""
    for i, char in enumerate(original_string):
        if i % 2 == 0:
            result_string += char.upper()
        else:
            result_string += char.lower()
    put_text(f"交替大小写转换后的字符串是：{result_string}")


if __name__ == "__main__":
    alternate_case_conversion()

代码解释：

1. 使用 pw_input 函数获取用户输入的字符串，存储在 original_string 中。
2. 初始化 result_string 为空字符串。
3. 使用 enumerate 函数遍历字符串，对于偶数索引的字符使用 upper 方法转换为大写，奇数索引的字符使用 lower 方法转换为小写，将结果添加到 result_string。
4. 最后输出结果。

点评： 本题考查 enumerate 函数的使用和大小写转换的灵活应用，让学生学会根据字符位置进行不同操作，同时通过 pywebio3 实现输入输出，提升对字符串操作和位置信息利用的能力。

练习四：字符串的格式化输出

题目： 使用 pywebio3 编写一个程序，让用户输入姓名、年龄和职业。程序需要使用 format 或 f-string 格式化输出一条信息，例如：“[姓名] 是一位 [年龄] 岁的 [职业]。”

分析： 本题主要考查学生对字符串格式化方法的掌握，包括 format 方法和 f-string 的使用，让学生根据用户输入的数据进行格式化输出。

参考代码：

from pywebio3.input import input_group, input
from pywebio3.output import put_text


def format_string_output():
    # 获取用户输入的姓名、年龄和职业
    data = input_group("请输入姓名、年龄和职业", [
        input(name='name',),
        input(name='age', type='number'),
        input(name='occupation',)
    ])
    name = data['name']
    age = data['age']
    occupation = data['occupation']
    formatted_string = "{0} 是一位 {1} 岁的 {2}。".format(name, age, occupation)
    # 或者使用 f-string: formatted_string = f"{name} 是一位 {age} 岁的 {occupation}。"
    put_text(formatted_string)


if __name__ == "__main__":
    format_string_output()

代码解释：

1. 使用 input_group 函数获取用户输入的姓名、年龄和职业，存储在 data 字典中。
2. 提取用户输入的数据存储在相应变量中。
3. 使用 format 方法或 f-string 对字符串进行格式化，将用户输入的数据填入相应位置。
4. 输出格式化后的字符串。

点评： 此练习旨在巩固学生对字符串格式化的掌握，让他们学会根据不同的输入数据生成规范的输出信息，同时使用 pywebio3 完成用户输入和结果输出，提高对字符串格式化的熟练度。

练习五：统计元音和辅音的数量

题目： 使用 pywebio3 编写一个程序，让用户输入一个字符串。程序需要统计该字符串中元音字母（a, e, i, o, u）和辅音字母的数量，并输出结果。

分析： 学生需要遍历字符串，使用 in 关键字检查字符是否为元音字母，同时使用条件判断和计数变量来统计元音和辅音的数量。

参考代码：

from pywebio3.input import input as pw_input
from pywebio3.output import put_text


def count_vowels_and_consonants():
    # 获取用户输入的字符串
    original_string = pw_input("请输入一个字符串：")
    vowel_count = 0
    consonant_count = 0
    vowels = "aeiouAEIOU"
    for char in original_string:
        if char in vowels:
            vowel_count += 1
        elif char.isalpha():
            consonant_count += 1
    put_text(f"元音字母的数量是：{vowel_count}，辅音字母的数量是：{consonant_count}")


if __name__ == "__main__":
    count_vowels_and_consonants()

代码解释：

1. 使用 pw_input 函数获取用户输入的字符串，存储在 original_string 中。
2. 初始化 vowel_count 和 consonant_count 为 0 分别用于统计元音和辅音的数量。
3. 定义元音字母集合。
4. 遍历字符串，若字符是元音字母，元音计数加 1；若字符是字母但不是元音字母，辅音计数加 1。
5. 输出元音和辅音的数量。

点评： 本题考查学生对字符的分类和计数，通过 in 关键字和 isalpha 方法的结合使用，培养学生对字符串元素的分类和统计能力，同时结合 pywebio3 进行用户输入和结果输出，加强对字符串处理和计数逻辑的掌握。

总结

本节课的主要学习内容聚焦于字符串的常用内置方法以及字符串的切片操作哦 我们一起深入探究了字符串在 Python 中的各种强大功能，详细了解了那些丰富多样的内置方法，它们就像一个个实用的小工具，能够帮助我们完成诸如大小写转换、查找替换、分割拼接、长度检查、去除空格以及判断统计等诸多操作呢 同时，我们还学习了字符串切片这一灵活且强大的技巧，通过简单的 start:end:step 表达式，就能从字符串中提取出我们想要的部分，真是既有趣又实用呀 为了更好地掌握这些知识点，我们还精心安排并完成了大量的练习，让大家在实践中亲身体验这些方法和技巧的实际运用，从而更加深入地理解它们的工作原理和使用场景呢 希望大家在完成这些练习的过程中，能够更加熟练地运用字符串操作，将这些知识变成自己解决问题的得力助手，为后续的编程学习打下坚实的基础哦 让我们一起在字符串的奇妙世界里继续探索，不断提升自己的编程水平吧

宝子们，我在 Python 的世界里摸爬滚打十余载，积累了不少心得体会。如今想把这些年的经验和知识毫无保留地分享给有缘的小伙伴。要是你对 Python 学习感兴趣，欢迎来试听一二，也可以随时在评论区留言或者私信我，咱们一起探讨，共同进步，开启 Python 学习的奇妙之旅！

人生苦短, 我用Python, 坚持每天学习, 坚持每天进步一点点...