Python 作业错题整理：作业6-Python中的字符串 & 作业7-Python的文件操作

作业6-Python中的字符串

语句print("输出结果是{:8s}".format("this"))的输出是：输出结果是 □□□□this。 □表示空格。 T F

答案：T（正确）

解析：

print("输出结果是{:8s}".format("this"))

• {:8s} 表示：将字符串格式化为 至少占 8 个字符宽度，默认右对齐，不足部分用空格填充。
• "this" 长度为 4，因此前面补 8 - 4 = 4 个空格。
• 所以最终格式化结果是：" this"（4 个空格 + "this"）

整个输出为：输出结果是 this

即：输出结果是□□□□this（□ 表示空格）

✅ 与题目描述一致。

补充说明：

• 如果是 {:>8s}：显式右对齐（默认行为）
• 如果是 {:<8s}：左对齐 → "this "
• 如果是 {:^8s}：居中 → " this "

但 {:8s} 默认就是右对齐。

✅ 判断题答案：T（正确）

语句print("输出结果是{:08.2f}".format(14.345))的输出是：输出结果是00014.34。 T F

答案：F（错误）

解析：

语句：

print("输出结果是{:08.2f}".format(14.345))

我们来逐步分析格式说明符 {:08.2f}：

.2f：表示保留2 位小数的浮点数。

• 14.345 四舍五入为 14.35（注意：不是 14.34！）
• 08：表示总宽度至少为 8 个字符，不足时用 前导零（0）填充。

• 对于浮点数，总宽度包括：

  • 整数部分
  • 小数点 .
  • 小数部分（2 位）
  • 可能的负号（这里没有）

所以：

• 格式化后的数字是：14.35
• 字符数：5（1, 4, ., 3, 5）
• 要达到总宽度 8，需在前面补 3 个 0
• 结果：00014.35

因此，完整输出是：

输出结果是00014.35

在 C/C++ 的 printf 中，%.2f 也是会四舍五入的

字符串的索引从1开始，因此第一个字符的索引为1，第二个字符的索引为2，依此类推。

TF

答案：F（错误）

解析：

在 Python 中，字符串的索引是从 0 开始的，不是从 1 开始。

print("12 "*3==" ".join(["12","12","12"])) 的输出是True。

TF

答案：F（错误）

左边："12 " * 3

• "12 " 是一个包含 '1', '2', ' '（空格）的字符串（长度为 3）

• 重复 3 次：

  "12 " * 3 → "12 12 12 "

  注意：末尾有一个空格！

  结构："12<空格>12<空格>12<空格>"

右边：" ".join(["12","12","12"])

• 用空格连接三个 "12"：

  " ".join(["12","12","12"]) → "12 12 12"

  注意：末尾没有空格！

结构："12<空格>12<空格>12"

对比：

• 左边："12 12 12 "（长度 9，末尾有空格）
• 右边："12 12 12"（长度 8，末尾无空格）

→ 两者 不相等

print(5+"class")运行后输出 5class。 T F

答案：F（错误）

在 Python 中，执行以下语句：

print(5 + "class")

会抛出类型错误（TypeError），不会输出 5class。

python中，所有的变量和常量都是有所属的类型的。

TF

答案：T（正确）

解析：

在 Python 中，一切皆对象（everything is an object），而每个对象都有一个类型（type）。

• 变量本身没有类型，但变量所引用的对象有类型。
• 常量（如 42、"hello"、3.14、True）也是对象，因此也有类型。

对于split()和rsplit()方法，如果不指定分隔符，则字符串中的任何空白符号（包括空格、换行符、制表符等）都将被认为是分隔符。

TF

答案：T（正确）

解析：

在 Python 中，字符串的 split() 和 rsplit() 方法在不指定分隔符（即调用时括号为空：.split() 或 .rsplit()）时，具有特殊行为：会将任意空白字符（whitespace）作为分隔符，并且会忽略开头、结尾和中间的多个连续空白，自动去除空字符串。

✅ 空白字符包括：

• 空格 ' '
• 制表符 '\t'
• 换行符 '\n'
• 回车 '\r'
• 换页 '\f'
• 垂直制表符 '\v'（在 Python 中也属于空白）

这些都属于 str.isspace() 返回 True 的字符。

print(s[6:-11])会倒置字符串吗？

不会，print(s[6:-11]) 不会倒置字符串，而且在这个具体例子中，输出为空字符串。

• s[6:-11] → 等价于 s[6:2] → 空字符串
• 倒置必须使用 负步长切片（如 [::-1]）

下列方法中，能够返回某个子串在字符串中出现的次数的是

A.count

B.find

C.index

D.rfind

正确答案：A. count

解析：

题目问的是：哪个方法能返回某个子串在字符串中出现的次数？

我们逐个分析选项：

A. count ✅

• 作用：返回子串在字符串中出现的次数。
• 语法：str.count(sub[, start[, end]])

• 示例：

  s = "hello world"
  print(s.count("l"))   # 输出：3
  print(s.count("o"))   # 输出：2

• ✔️ 完全符合题意。

B. find ❌

• 作用：返回子串第一次出现的索引，如果没找到返回 -1。
• 不返回次数。

• 示例：

  "hello".find("l")  # 返回 2（第一次出现的位置）

C. index ❌

• 类似 find，但找不到时抛出 ValueError 异常。
• 也只返回第一次出现的位置，不是次数。

D. rfind ❌

• 返回子串最后一次出现的索引，不是次数。

✅ 结论：

只有 count 方法用于统计子串出现的次数。

答案：A. count

✅ 常见的转义字符（以反斜杠 \ 开头）：

已知：s="abc123"，下面（ ）选项的运行结果是True A. s.isalnum() B. s.islower() C. s.isdigit() D. s.isdecimal()

所以，A B

对于如下代码：

import string
var='abcd01234adfda'

想去除字符串首尾的字母，只留下数字“01234”，可使用下面的哪条语句?

A.

print(var.strip('abcdf'))

B.

print(var.strip('bcdfa'))

C.

print(var.strip(string.ascii_lowercase))

D.

print(var.strip(string.ascii_letters))

• 方法：使用 str.strip(chars) —— 从字符串开头和结尾移除 chars 中包含的字符，直到遇到不在 chars 中的字符为止。
• string.ascii_lowercase：仅小写字母
• string.ascii_letters：大小写都包括

所以，C D

★对于变量var=1234，占用10个字符位置，右对齐输出，前面补0，可采用如下语句：

A.

print('%010d' % (var))

B.

print('{:0>10d}'.format(var))

C.

print(str(var).rjust(10,'0'))

D.

print(str(var).zfill(10))

✅ 题目要求：

• 变量 var = 1234
• 占用 10 个字符位置
• 右对齐输出
• 前面补 0

即期望输出为：

0000001234

（共 10 位，前面补 6 个 0）

分析各选项：

A. print('%010d' % (var))

• 这是 旧式格式化（% 格式化）
• %010d 表示：十进制整数，总宽度 10，不足部分前面补 0
• 输出：0000001234 ✅

✔️ 正确

B. print('{:0>10d}'.format(var))

• 新式 .format() 格式化

• {:0>10d}

  解析：

  • >：右对齐（默认数字就是右对齐，但显式写出）
  • 0：填充字符为 0
  • 10：总宽度 10
  • d：整数

• 输出：0000001234 ✅

  ✔️ 正确

  注：也可以简写为 {:010d}，因为数字默认右对齐。

  C. print(str(var).rjust(10,'0'))

• str(var) → '1234'
• .rjust(10, '0')：右对齐，总宽 10，左边用 '0' 填充

• 输出：0000001234 ✅

  ✔️ 正确

  D. print(str(var).zfill(10))

• zfill(width)：在字符串左侧填充 0，直到达到指定宽度
• 特别注意：如果字符串以符号开头（如 '+' 或 '-'），0 会填在符号之后
• 但这里 str(1234) = '1234'，无符号

• zfill(10) → '0000001234' ✅

  ✔️ 正确

  结论：

  ✅ A、B、C、D 四个选项都能正确输出 0000001234

  作业7-Python的文件操作

  open("test.txt", 'r+')是以只读模式打开test.txt文件。

  TF

  F

  open("test.txt", 'r+') 是以读写模式打开文件，而不是只读模式。'r+' 模式允许对文件进行读取和写入操作。

  二进制文件不能使用记事本程序打开。

  TF

  F 错误。虽然二进制文件可以用记事本打开，但通常显示为乱码，无法正常阅读内容。但“不能”这个词过于绝对，技术上是可以打开的。

  以读模式打开文件时，文件指针指向文件开始处。

  TF

  T 正确。在 'r' 或 'r+' 等读模式下，文件指针初始位置在文件的开头。

  文件打开的默认方式是只读。

  TF

  T（正确）

  在 Python 中，使用内置函数 open() 打开文件时，如果不指定模式参数，默认是以只读文本模式（即 'r' 模式）打开文件。

  以下选项对文件描述错误的是：

  A.

  文本文件不能用二进制文件方式读入

  B.

  文件中可以包含任何数据内容

  C.

  文本文件和二进制文件都是文件

  D.

  文件是一个存储在辅助存储器上的数据序列

  正确答案是：A. 文本文件不能用二进制文件方式读入

• A. 错误（本题选此项）
  文本文件可以用二进制方式读入。例如，在 Python 中，你可以用 'rb' 模式打开一个文本文件，此时读取的是原始字节（bytes），而不是字符串。虽然这不是常规做法，但技术上完全可行。因此，说“不能”是错误的描述。
• B. 正确
  文件本质上是存储在磁盘上的数据，可以包含任意内容（文本、图像、音频、程序代码等），所以“文件中可以包含任何数据内容”是合理的说法。
• C. 正确
  文件按内容解释方式可分为文本文件和二进制文件，但它们都是“文件”的具体类型。

• D. 正确
  文件确实是存储在辅助存储器（如硬盘、SSD）上的数据序列，这是文件的基本定义。

  以下选项中，不是 Python 中文件操作的相关函数是

  A.open()

  B.read()

  C.load()

  D.write()

  Python 中对文件的基本操作主要通过内置函数和文件对象的方法实现：

• A. open()
  ✅ 是 Python 内置函数，用于打开文件，返回一个文件对象。
• B. read()
  ✅ 是文件对象的方法，用于读取文件内容。
• D. write()
  ✅ 是文件对象的方法，用于向文件写入内容。

• C. load()
  ❌ 不是 Python 文件操作的通用内置函数。

  • load() 是 pickle 模块 或 json 模块 中的函数（如 pickle.load()、json.load()），用于反序列化数据，但它不是直接用于通用文件操作的函数。
  • 文件本身没有 .load() 方法，也不能像 read() 那样直接用于读取原始文件内容。

  因此，load() 不属于 Python 中直接的文件操作函数。

  以下选项中，不是 Python 文件打开的合法模式组合是

  A."a+"

  B."t+"

  C."r+"

  D."w+"

  正确答案是：B. "t+"

  解析：Python 文件打开模式

  Python 中 open() 函数的模式由访问模式（如读、写、追加）和文件类型（文本或二进制）组成。

  常见访问模式：

• 'r'：只读（默认）
• 'w'：写入（覆盖）
• 'a'：追加
• 'x'：独占创建

• 加上 '+' 表示读写（如 'r+'：读写，文件必须存在；'w+'：读写，会清空文件；'a+'：读写，指针在末尾）

  文件类型：

• 't'：文本模式（默认），可省略（如 'rt' 等价于 'r'）
• 'b'：二进制模式（如 'rb', 'wb'）
• A. "a+"
  ✅ 合法。以追加和读取方式打开文本文件（默认是文本模式）。

• B. "t+"
  ❌ 非法。't' 只是表示文本模式，但它不能单独作为访问模式。必须与 'r'、'w'、'a' 等一起使用，如 'rt+'、'wt+'。
  单独使用 "t+" 缺少基本的访问方式（读/写/追加），Python 会报错：

  ValueError: invalid mode: 't+'

• C. "r+"
  ✅ 合法。以读写方式打开已有文本文件。

• D. "w+"
  ✅ 合法。以写读方式打开文件（会清空原内容）。

  以下哪个步骤在文件和程序之间创建连接？

  A.打开文件

  B.读取文件

  C.处理文件

  D.关闭文件

  正确答案：A. 打开文件

  ✅ 解析：
  使用 open() 函数打开文件时，操作系统会建立程序与文件之间的连接（返回一个文件对象），后续的读、写、关闭等操作都基于这个连接。
  因此，“打开文件”是创建连接的步骤。

  一般来说，Python把文件分为几种文件类型？

  A.1

  B.2

  C.3

  D.4

  正确答案：B. 2

  ✅ 解析：
  Python 将文件主要分为两类：

• 文本文件（text files） —— 以字符为单位，自动处理编码（如 UTF-8）

• 二进制文件（binary files） —— 以字节为单位，不进行编码转换

  虽然实际存储都是二进制，但从访问方式和解释方式来看，Python 明确区分这两种类型（通过 't' 或 'b' 模式）。

  因此，答案是 B. 2。

  r+ 和 w+ 都是 Python 中用于读写文件的模式，但它们在文件是否存在、是否清空内容、指针初始位置等方面有关键区别。下面是详细对比：

  ✅ 1. 文件必须存在吗？

  模式	文件必须存在？	不存在时行为
  r+	✅ 是	抛出 FileNotFoundError
  w+	❌ 否	自动创建新文件

  ✅ 2. 是否会清空原有内容？

  模式	是否清空原内容？
  r+	❌ 不会清空，保留原内容
  w+	✅ 会立即清空整个文件（即使你只想读）

  ⚠️ 注意：w+ 一打开文件，原内容就没了！

  ★Python标准库os中用来列出指定文件夹中的文件和子文件夹列表的方式是（ ）。

  A.listfile()

  B.listdirs()

  C.listdir()

  D.listfiles()

  正确答案是：C. listdir()**

  解析：

  Python 标准库 os 中，用于列出指定文件夹中的文件和子文件夹名称列表的函数是：os.listdir(path='.')

• 返回值：一个列表，包含 path 目录下所有文件和子目录的名称（不包括 . 和 ..）。
• 不递归子目录，仅列出当前层级的内容。

• 如果未指定 path，默认列出当前工作目录的内容。

  ✅ 示例：

  import os
  files_and_dirs = os.listdir('/home/user')  # Linux/macOS
  # 或
  files_and_dirs = os.listdir('C:\\Users')   # Windows
  print(files_and_dirs)

  其他选项分析：

• A. listfile() ❌
  不存在于 os 模块中。
• B. listdirs() ❌
  不是标准库函数（虽然有些第三方库可能有类似命名）。

• D. listfiles() ❌
  同样不是 os 模块中的函数。

  💡 注意：os.listdir() 返回的是文件和目录的混合列表。若要区分，可结合 os.path.isfile() 和 os.path.isdir() 使用。

  ✅ 正确答案：C. listdir()

  以下选项不是Python文件读操作的是：

  A.readtext()

  B.read()

  C.readlines()

  D.readline()

  ✅ 正确答案：A. readtext()

  解析：
  Python 文件对象（由 open() 返回）支持的标准读取方法包括：

• read()：读取全部或指定数量的字符
• readline()：读取一行

• readlines()：读取所有行，返回列表

  但 readtext() 不是 Python 内置的文件方法，标准库中不存在此函数。

  若文本文件abc.txt中的内容如下：

  abcdef

  阅读下面的程序：

  file = open("abc.txt", "r")

  s = file.readline()

  s1 = list(s)

  print(s1)

  上述程序执行的结果为（ ）。

  A.['abcdef']

  B.['abcdef\n']

  C.['a', 'b', 'c', 'd', 'e', 'f']

  D.['a', 'b', 'c', 'd', 'e', 'f', '\n']

  正确答案是：D. ['a', 'b', 'c', 'd', 'e', 'f', '\n']

  详细解析：

• 文件内容：

  题目中说 abc.txt 的内容是：abcdef

  注意：在文本文件中，一行的末尾通常包含换行符 \n（除非文件最后一行明确没有换行）。

  因此，实际存储的内容很可能是：'abcdef\n'

  ✅ 在大多数编辑器中（如记事本、VS Code 等），即使你只输入 abcdef 并保存，系统也会自动在行尾加上 \n（尤其是 Unix/Linux/macOS 系统）。Windows 使用 \r\n，但 Python 在文本模式下会统一转为 \n。

  程序执行过程：

  file = open("abc.txt", "r")
  s = file.readline()        # 读取一行，包括末尾的换行符 '\n'
  s1 = list(s)               # 将字符串转为字符列表
  print(s1)

  readline() 的行为：读取直到遇到换行符 \n，并把 \n 也包含在返回的字符串中。

  所以 s = 'abcdef\n'

  list(s)会把每个字符拆开，包括\n

  list('abcdef\n') → ['a', 'b', 'c', 'd', 'e', 'f', '\n']

  对文件进行写入操作之后，__方法用来在不关闭文件对象的情况下将缓冲区内容写入文件。

  ✅ 答案：flush()

• 文件写入通常先写入缓冲区，调用 flush() 可强制将缓冲区内容写入磁盘，而不关闭文件。

  在读写文件的过程中，（ ）方法可以获取当前的读写位置。

  ✅ 答案：tell()

• tell() 返回文件指针当前的偏移位置（字节位置）。

  seek方法用于移动指针到指定位置，该方法中（ ）参数表示要偏移的字节数。

  offset）

  语法：seek(offset, whence=0)

  offset：要偏移的字节数（第一个参数）

  whence基准位置（0=文件开头，1=当前位置，2=文件末尾）

  在文本模式下，通常只能使用 seek(0) 或 seek(f.tell())；二进制模式支持任意偏移。

  7-1 综合题：学生成绩输入及输出

  输入n(1<n<=100)个学生的信息，包括学号、姓名、语文、数学和英语。学号为4位数字组成，成绩为整数，如果不满足此条件，出现异常，如果输入的n不是数字或者 n<=1或ｎ＞100，出现异常，输出“输入的人数必须是数字,大于0并且小于等于100”。要求根据3门功课的平均成绩从高分到低分输出每个学生的学号、姓名、3门功课成绩及平均成绩，若平均成绩相同则按语文成绩从高到低排序。

  输入格式:

  每组测试数据首先输入一个正整数n(1<n<=100)，表示学生人数；然后是n行信息，分别表示学生的学号、姓名（长度不超过10且由英文字母构成的字符串）和3门课成绩（正整数）。

  输出格式:

  如果n出现错误，出现异常。如果n输入正确，输出排序后的学生信息，每行一个学生信息：学号、姓名、语文、数学、英语、平均成绩（保留2位小数），上面每个数据之间留一个空格。

  输入样例:

  在这里给出多组。例如：

• zhangsan 80 95 65
• lisi 65 52 56

• wangwu 87 86 95

  
  输出样例:
  
  在这里给出相应的输出，文件中与输出一样。例如：
  

• wangwu 87 86 95 89.33
• zhangsan 80 95 65 80.00

• lisi 65 52 56 57.67

  class Student:
  def __init__(self, student_id, name, chinese, math, english):

    self.student_id = student_id
    self.name = name
    self.chinese = chinese
    self.math = math
    self.english = english
    self.average = (chinese + math + english) / 3
  

def main():

try:
    # 读取学生人数
    n_input = input().strip()
    if not n_input.isdigit():
        raise ValueError("输入的人数必须是数字,大于0并且小于等于100")
    
    n = int(n_input)
    if n <= 1 or n > 100:
        raise ValueError("输入的人数必须是数字,大于0并且小于等于100")
    
    students = []
    
    # 读取每个学生的信息
    for _ in range(n):
        data = input().split()
        
        # 检查输入格式
        if len(data) != 5:
            raise ValueError("输入格式错误")
        
        student_id, name = data[0], data[1]
        chinese_str, math_str, english_str = data[2], data[3], data[4]
        
        # 验证学号（4位数字）
        if len(student_id) != 4 or not student_id.isdigit():
            raise ValueError("学号必须是4位数字")
        
        # 验证成绩是否为整数
        try:
            chinese = int(chinese_str)
            math = int(math_str)
            english = int(english_str)
        except ValueError:
            raise ValueError("成绩必须是整数")
        
        # 创建学生对象
        student = Student(student_id, name, chinese, math, english)
        students.append(student)
    
    # 排序：先按平均分降序，平均分相同按语文成绩降序
    students.sort(key=lambda x: (-x.average, -x.chinese))
    
    # 输出结果
    for student in students:
        print(f"{student.student_id} {student.name} {student.chinese} {student.math} {student.english} {student.average:.2f}")

except ValueError as e:
    if str(e) == "输入的人数必须是数字,大于0并且小于等于100":
        print("输入的人数必须是数字,大于0并且小于等于100")
    else:
        # 其他异常情况
        print("输入格式错误")

if name == "__main__":

main()

欲打印出信息：“我叫小明，今年 10 岁! ”（不包括双引号），可使用的语句包括：

A.

print ("我叫%s,今年%d岁!" % ('小明', 10))

B.

class Student:

def __init__(self, name,age):
    self.name = name
    self.age=age

stu = Student('小明', 10)
print('我叫{0.name},今年{0.age}岁!'.format(stu))

C.

dct={'name':'小明','age':10}
print('我叫{name},今年{age}岁!'.format(**dct))

D.

lst=['小明', 10]
print('我叫{0[0]},今年{0[1]}岁!'.format(lst))

ABCD

★`len('3//11//2018'.split('/'))`的结果是（    ）。

- 字符串：`'3//11//2018'`
- 按'/'分割：
  - `'3'`, `''`, `'11'`, `''`, `'2018'`
- 所以列表长度 = 5

✅ 答案：**5**

下面程序的输出是什么？

some_string = "Hi!......"
print(some_string.strip(".!"))

Hi

`strip()` 方法用于移除字符串**首尾**指定的字符（默认为空白字符）。

在这个例子中：

- `some_string = "Hi!......"`
- `strip(".!")` 表示移除字符串开头和结尾的所有 `.` 和 `!` 字符

字符串 `"Hi!......"` 的分析：

- 开头：`"H"` 不是 `.` 或 `!`，所以不移除
- 结尾：从 `"!"` 开始到最后的 `"......"` 都是 `.` 或 `!`，所以全部移除

移除过程：

- 原字符串：`"Hi!......"`
- 移除结尾的 `!` 和 `......` 后得到：`"Hi"`

其他相关方法：

- `lstrip()` - 只移除开头字符
- `rstrip()` - 只移除结尾字符







## 、补充

语句b = 1，2，3有语法错误。  

TF



答案：F，b被赋值为元组

Python中列表的元素个数可以是无限个。

TF

答案：T，可以有无数个元素

tuple(x)：可以用于生成元组，输入的参数可以是任何组合数据类型。 (2分)  

TF

答案：T，可以是任何组合数据类型

`print(sum((1,3,5,7,9))/len((1,3,5,7,9)))`的输出是

2 分 。



**应该输出5.0，除法默认结果为1位浮点数**

**下面定义字典的语句那个是正确的？**

**A.****momthdays=dict(Jan=31,Feb=28,Mar=31,Apr=30)**

**B.****momthdays=dict("Jan"=31,"Feb"=28,"Mar"=31,“Apr"=30)**

**C.****momthdays={Jan:31,Feb:28,Mar:31,Apr:30}**

**D.****momthdays={Jan=31,Feb=28,Mar=31,Apr=30}**



**\# 以列表的形式输出字典 D 的所有键值对；**

print(list(D.items()))

1 分

易错：

阅读下面程序，只能输入三个成绩，如依次输入：78，90，67，输出结果：“共输入了3个人的成绩，他们的平均成绩是78.33”。

num=input("请输入学生成绩：")
ls=[]
sum=0
while num!='':

 ls.append(num)  
 sum=sum+eval(num)  
 num=input("请输入学生成绩：")  

n=len(ls)
print('共输入了{}个人的成绩，他们的平均成绩是{:.2f}'.format(n,sum/n))

TF

评测结果

答案错误

得分

0 分

1. 第一次输入：78 → 添加到ls，sum=78
2. 第二次输入：90 → 添加到ls，sum=168
3. 第三次输入：67 → 添加到ls，sum=235
4. 第四次输入：''（空字符串）→ 循环结束

关于Python的无限循环，以下（）选项描述正确。

A.无限循环也称为条件循环

B.无限循环不需要提前确定循环体执行的次数

C.无限循环直到循环条件不满足时才结束

D.无限循环通过while保留字构建

B。

C错误，只能break

**语句`print("输出结果是{:8s}".format("this"))`的输出是：输出结果是 □□□□this。**
 **□表示空格。**

**TF**

**评测结果**

**答案错误**

**字符串格式化，默认左对齐！！**



下列方法中，用于获取当前目录的是（   ）。

A.open 

B.write

C.getcwd

D.read

C。



loaddir()