Python Input and Output

1.导入必要的包和函数

1.1 开根号函数

from math import sqrt  # 程序开头引入开根号函数
x = int(input())
y = sqrt(x) # 开根号函数
print(y)

2. input()读入函数

2.1 普通读入

2.1.1 让我们来查看input()的读取类型:

a = input()
print(a, type(a))

type() 是 Python 的内置函数，用来查看变量的类型是 int、float、str 等。

输入1：

输出1：

123 <class 'str'>

输入2：

Iphone 100 promax

输出2：

Iphone 100 promax <class 'str'>

上面的实操说明：

无论你在 input() 里输入数字还是文字，结果都是字符串（str）类型。
这是 Python 的规则：input() 接收的内容永远是字符串。input() 接收的内容永远是字符串。
也就是说，123 只是长得像数字，它仍然是字符串。

2.1.2 常见错误:从键盘读入两个整数，计算两个整数的和

执行以下代码：

a = input('请输入一个加数：')
b = input('请输入另一个加数：')
print(type(a), type(b))
print(a+b)

输出：

请输入一个加数：13
请输入另一个加数：24
<class 'str'> <class 'str'>
1324

错误原因：实际上只进行了简单拼接str的操作。

2.1.3 代码应该修改为：

a = input('请输入一个加数：')
b = input('请输入另一个加数：')
print(type(a), type(b))
print(int(a) + int(b))

输出：

请输入一个加数：13
请输入另一个加数：24
<class 'str'> <class 'str'>
37

可以看到a, b仍然是字符串类型，但是在print()时进行了类型转换（字符串转整数)，所以可以进行整数相加

input()函数读取的一切键盘输入默认为str，需要转类型。
可以用a=int(a)，类型转换后print(a+b)即可。
或者在读取时用a=int(input('请输入一个加数：'))，提前转换。

2.2 读入

2.2.1 读入一行字符串（不做 split）

s = input()

s = input().strip() #去空格和制表符

2.2.2 读入一行逗号分隔的字符串

words = input().split(',')

示例输入：

apple,banana,orange

2.2.3 一行读入一个整数/浮点数

a = int(input())

b = float(input())

2.2.4 读入一行空格分隔的两个整数

a, b = map(int, input().split())

2.2.5 读入一行 # 分隔的两个整数

a, b = map(int, input().split('#'))

示例输入：

1#2

2.2.6 读入一行逗号分隔的三个整数

a, b, c = map(int, input().split(','))

示例输入：

1,2,3

2.2.7 读入一行无限长度、逗号分隔的整数

nums = list(map(int, input().split(',')))

示例输入：

1,2,3,4,5

2.2.8 混合格式：数字后有空格和逗号

nums = list(map(int, input().replace(',', ' ').split()))

示例输入：

1, 2, 3, 4

2.2.9 读入两行数，每行各一个数（浮点或整数）

a = int(input())
b = int(input())

a = float(input())
b = float(input())

2.2.10 输入固定数量的数，但在多行中

n = int(input())
nums = [int(input()) for _ in range(n)]

示例输入：

2.2.11 多组测试用例，T 组输入，每组 2 个数

t = int(input())
for _ in range(t):
    a, b = map(int, input().split())
    print(a + b)

示例输入：

2.2.12 循环读入多行浮点数：

for i in range(6):
	x = float(input())

· range(start, stop, step)
· range(6)是range(,6,)的简写(但只想写stop的时候不能加逗号，会报错），意思是i从0读到5，一共循环6次，读入6次输入变量X

2.2.13 循环输入多行整数，直到用户输入0停止：

while True:
   X = int(input())
    if X == 0:
        break

2.2.14 循环输入，直到遇到某个结束符停止：

while True:
    a, b = map(int, input().split())
    if a == 0 and b == 0:
        break

示例输入：

1 2
3 4
0 0

2.2.15 输入直到 EOF（文件结束）,适用于多行数据不固定的在线题：

import sys

mat = [list(map(int, line.split())) for line in sys.stdin]

2.2.16 读入字典 / key=value 格式

pairs = input().split()
dic = {p.split('=')[0]: int(p.split('=')[1]) for p in pairs}

示例输入：

a=3 b=5 c=9

2.2.17 文件读入多行或 input() 得到的字符串带 \n、空格、制表符，去掉换行和空格的写法：

a = int(input().strip())
b = int(input().strip())
c = int(input().strip())
.....


a = float(input().strip())
b = float(input().strip())
c = float(input().strip())
.....

strip()使用说明：是 Python 的字符串方法,用于去掉字符串开头和结尾的空白字符（whitespace）

包括：

空格 " "
换行 \n
制表符 \t
回车 \r
其他不可见空白字符

例 1：去掉输入后附带的换行

A = int(input().strip())

用户输入时可能会带换行（回车），
strip() 会先把空白去掉，再交给 int() 转换。

例 2：普通字符串

s = "   hello world   "
print(s.strip())

输出：

hello world

例 3：去掉换行

s = "hello\n"
print(s.strip())

输出：

hello

strip() vs lstrip() vs rstrip()

方法	功能
strip()	去掉左右两边空白
lstrip()	去掉左边空白
rstrip()	去掉右边空白

为什么 input().strip() 很常见？

因为用户输入可能多了一些空格、换行，例如：

如果直接 int(input())，会报错。
但 int(input().strip()) 就安全多了。

2.2.18 矩阵输入（二维数组）,已知矩阵大小 n 行 m 列

示例1：

n, m = map(int, input().split())
mat = [list(map(int, input().split())) for _ in range(n)]

示例输入：

示例2：

n, m = 3, 4  # 3 行 4 列
matrix = [list(map(int, input().split())) for _ in range(n)]

示例输入：

1 2 3 4
5 6 7 8
9 0 1 2

在上面的示例代码里只用到了 n，完全 没有用到 m。换句话说： m 在代码里没有任何作用。

那为什么很多人写 n, m？因为矩阵通常有两个维度：

n = 行数
m = 列数

应该用 m 来检查每行是否输入正确的列数：

n, m = 3, 4
m = []
for _ in range(n):
    row = list(map(int, input().split()))
    if len(row) ! = m:
        print("列数不正确！")
    matrix.append(row)

或者用列表推导式 + 列数检测（专业写法）：

n, m = 3, 4
matrix = [list(map(int, input().split())) for _ in range(n)]

for row in matrix:
    assert len(row) == m, "列数错误"

需要控制列数的情况：读取矩阵为一个长字符串并切割（不常用）

n, m = 3, 4  # 3 行 4 列
data = input().split()  # 读取所有输入并按空格分割
matrix = [list(map(int, data[i * m:(i + 1) * m])) for i in range(n)]

# 打印矩阵
for row in matrix:
    print(row)

输入样例：

1 2 3 4 5 6 7 8 9 10 11 12

输出：

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

2.2.19 n行矩阵，不知列数

只控制行数 n
不关心每行有多少列
用户输入多少列，你就读多少列

方法 1：使用 list(map(int,...)) 循环读入每一行（适合手动输入）

M = []
for i in range(n): # n可以直接用数代替，也可以读取用户输入
    row = list(map(int, input().split()))  # 输入一行，并转换成整数
    M.append(row)

# 打印矩阵
for row in matrix:
    print(row)

map(int, input().split())解释:

input().split()        → ["1", "2", "3"]，把一行输入按空格切成字符串列表
map(int, ...)          → (1, 2, 3)，把每个字符串转换成整数的 map 对象
list(map(...))         → [1, 2, 3]，把 map 结果变成真正的列表

输入样例：

1 2 3 4
5 6 7 8
9 10 11 12

输出：

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

这是因为 打印方式 决定了每个元素“看起来”占一行。

要理解这一点，我们要分清楚 数据结构 和 打印方式 之间的区别。

数据结构里没有换行

例如矩阵：

M = [
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0]
]

在内存里，它就是 一个包含两个列表的列表。

没有换行符 \n，没有回车，只是列表里包含列表。

看到“每个元素占一行”的原因

是因为你写了下面的打印方式：

for row in M:
    print(row)

而 print(row) 自带换行功能
所以每次循环都会换到下一行打印。

因此输出是：

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

每个元素（row）都被 print 单独打印，其本质是：

print(M[0])
print(M[1])

每次 print 自动换行 → 看起来像每个元素占一行。

如果你改变打印方式，就不会换行

例如：

print(M)

输出：

[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12]

全部在同一行。

再例如：

for row in M:
    print(row, end=" ")

输出：

[1.0, 2.0, 3.0] [4.0, 5.0, 6.0]

就没有换行了。

方法 2：使用列表推导式（更简洁）

n = int(input())
M = [list(map(int, input().split())) for _ in range(n)]

# 打印矩阵
for row in M:
    print(row)

输入样例：

1 2 3 4
5 6 7 8
9 10 11 12

输出：

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

row 明明没有提前定义，为什么能用？
因为 Python 的 for 循环会自动创建这个变量

就像：

for x in [10, 20, 30]:
    print(x)

这里 x 也没有提前定义，但 Python 会自动让：

第一次循环：x = 10

第二次循环：x = 20

第三次循环：x = 30

同理：

for row in M:

Python 会自动让：

第一次：row = M[0]

第二次：row = M[1]

第三次：row = M[2]

方法 3：使用 `numpy` 库读取矩阵（适合更复杂的计算）

import numpy as np

n = int(input())
matrix = np.array([list(map(int, input().split())) for _ in range(n)])

# 打印矩阵
print(matrix)

输入样例：

1 2 3 4
5 6 7 8
9 10 11 12

输出：

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

方法 4：从文件读取矩阵（适用于文件输入）

如果数据来自文件，你可以这样读取矩阵：

with open('matrix.txt', 'r') as file:
    matrix = [list(map(int, line.split())) for line in file]

# 打印矩阵
for row in matrix:
    print(row)

输入文件（matrix.txt）：

1 2 3 4
5 6 7 8
9 10 11 12

输出：

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

2.2.20 未知行数的输入

from sys import stdin

for line in stdin.readlines():
    print(line.strip())  # strip()是为了去掉行末的回车

2.3 详解 row = list(map(int, input().split()))

2.3.0 list 和 map 在 Python 中不是关键字（keyword）！

它们是：

list：内置类型（built-in type）
map：内置函数（built-in function）

Python 的关键字是像 if、for、while、class、def 这种语言本身的语法结构部分。

2.3.1 input()：读入一行字符串

例如输入：

1 2 3 4

2.3.2 input().split() 会把它按空格切成列表：

["1" "2" "3" "4"]

2.3.3 map(函数, 可迭代对象) 表示把某个函数作用到列表每一个元素上。这里是：

map(int, ["1" "2" "3" "4"])

效果就是把每个字符串转换成整数，变成类似这样：

map object: (1 2 3 4)

2.3.4 为什么不能只写：

row = list(input().split())

结果是：

["1" "2" "3"]

注意：都是字符串，不是数字！题目需要数字类型（int或float),必须用 map(int, input().split()) 转换。

注意，这时它还不是列表，而是一个 “map 对象(map object)”。map() 不是直接生成列表，而是返回一种惰性迭代器”（lazy iterator），称为map 对象。

2.3.5 迭代器（iterator）的核心特点

迭代器（iterator） = 一次只生成一个元素的惰性数据流。

特点	解释
一次取一个	每次只产生一个元素
惰性（lazy）	不会一次性占用大内存
只能往前、不能回头	取过的就没了
高效处理大数据	非常省内存

举例说明:

m = map(int, ["1", "2", "3"])
print(m)

输出类似：

<map object at 0x7fd5b...>

这表明它是一个 map 迭代器，不是列表！

2.3.6 迭代器的理解

想象你有一本书：列表像整个书放在你桌上,你可以随时翻。

迭代器像一个“自动翻页器”,它一次只给你一页，翻过的页不能回头。：

next(it) → 第一页
next(it) → 第二页
next(it) → 第三页

只能用 next() 来“拿”里面的东西：

it = iter([1, 2, 3])

next(it)  # 1
next(it)  # 2
next(it)  # 3
next(it)  # StopIteration（没了）

2.3.7 为什么 map() 会返回迭代器？

因为：

不用一次性计算全部结果（省内存）
更适合处理大输入数据
Python 3 统一很多函数返回 iterator，提高效率

3. print()输出函数

使用方法：print()函数输出多个变量，默认用空格隔开，且行末会默认添加回车。

3.1 常见简单输出

# 输出数字
print(520)
print(98.5)

# 输出字符串
print('hello world') # 单引号内内容直接输出
print("hello world") # 双引号内内容直接输出

# 输出计算后内容 
print(3 + 1) # 含有运算符的表达式，会计算

# 输出数据到文件当中
fp = open('D:/test.txt', 'a+') # 输出在文件中，a+表示以读写功能创建，文件不存在就创建，存在的话就在文件内容后继续追加
print('hello world', file=fp)  # 1.所指定的盘符必须存在 2.使用file=fp 把打印内容输出到fp当中，不用file的话文件里没有东西
fp.close()

# 不进行换行输出（输出内容在一行当中） 用逗号进行分隔
print('hello', 'world', 'Python')

输出：

520
98.5
hello world
hello world
4
hello world Python

3.2 自定义行末字符，需要添加end参数：

a, b, c = 1, 2, 'x'
print(a, b, c, end='!')
print(a)
print(b)
print(c)

3.3 保留若干位小数，此时可以使用round()函数：

x = 12.34567
print("x = " + str(round(x, 1)))  # 保留1位小数
print("x = " + str(round(x, 3)))  # 保留3位小数

3.4 使用格式化字符串控制输出格式：

x = 12.34567
y = 12

print("x = %d" % x)  # 输出整数
print("x = %.0f, y = %.0f" % (x, y))   #保留0位小数，就是输出整数
print("x = %d y = %d" % (x, y))  # 输出两个整数（用空格隔开）
print("x = %d;y = %d" % (x, y))  # 输出两个整数（用分号隔开）

print("x = %.1f" % x)  # 保留1位小数
print("x = %.3f" % (x * y))  # 保留3位小数

print("x = %f, y = %d" % (x, y))  # x 输出小数，y 输出整数

3.5 使用f-string控制输出格式（Python 3.6+，推荐使用)

a = int(input())
b = float(input())


print(f"我的账户余额是 {a} 元") # 直接在语句里把之前定义的变量使用花括号{}写进去就可以

print(f"{a};{b} 是一组用分号隔开的数！")  # f-string输出变量，直接在语句里的变量上打花括号{}就行

print(f"圆周率保留四位小数是{b:.4f}") # 保留4位小数

print(f"{int(b)}是一个整数！")   # 在 花括号{} 内使用 int() 将变量 b 转换成整数类型，再把它格式化输出到字符串里面

3.6 补充：int() 转换规则

"123" 这样的字符串 → 整数123
不能转换的字符串 "abc" → 报错
小数 3.9 → 3（向下取整，不是四舍五入）

例1：

b = 3.9
print(f"{int(b)}是一个整数！")

输出1：

3是一个整数！

因为 int(3.9) → 3

例2：

s = "123"        # 这是字符串，不是数字
n = int(s)       # 用 int() 把它转成数字
print(n, type(n))

输出2：

123 <class 'int'>

为什么要转换？

因为：

s = "123" —— 是字符串（str）
n = 123 —— 是整数（int）

字符串不能做数学运算：

s + 1   # ❌ 报错

但转成整数后就可以：

n + 1   # ✔ 124

总结: int() 可以把“看起来像数字的字符串”变成真正的数字。

posted @ 2025-11-24 04:12 Stéphane 阅读(17) 评论(0) 收藏举报

刷新页面返回顶部

Stéphane

Python Input and Output

1.导入必要的包和函数

1.1 开根号函数

2. input()读入函数

2.1 普通读入

2.1.1 让我们来查看input()的读取类型:

2.1.2 常见错误:从键盘读入两个整数，计算两个整数的和

2.1.3 代码应该修改为：

2.2 读入

2.2.1 读入一行字符串（不做 split）

2.2.2 读入一行逗号分隔的字符串

2.2.3 一行读入一个整数/浮点数

2.2.4 读入一行空格分隔的两个整数

2.2.5 读入一行 # 分隔的两个整数

2.2.6 读入一行逗号分隔的三个整数

2.2.7 读入一行无限长度、逗号分隔的整数

2.2.8 混合格式：数字后有空格和逗号

2.2.9 读入两行数，每行各一个数（浮点或整数）

2.2.10 输入固定数量的数，但在多行中

2.2.11 多组测试用例，T 组输入，每组 2 个数

2.2.12 循环读入多行浮点数：

2.2.13 循环输入多行整数，直到用户输入0停止：

2.2.14 循环输入，直到遇到某个结束符停止：

2.2.15 输入直到 EOF（文件结束）,适用于多行数据不固定的在线题：

2.2.16 读入字典 / key=value 格式

2.2.17 文件读入多行 或 input() 得到的字符串带 \n、空格、制表符，去掉换行和空格的写法：

2.2.18 矩阵输入（二维数组）,已知矩阵大小 n 行 m 列

应该用 m 来检查每行是否输入正确的列数：

或者用列表推导式 + 列数检测（专业写法）：

需要控制列数的情况：读取矩阵为一个长字符串并切割（不常用）

2.2.19 n行矩阵，不知列数

方法 1：使用 list(map(int,...)) 循环读入每一行（适合手动输入）

数据结构里 没有换行

看到“每个元素占一行”的原因

如果你改变打印方式，就不会换行

方法 2：使用列表推导式（更简洁）

方法 3：使用 numpy 库读取矩阵（适合更复杂的计算）

方法 4：从文件读取矩阵（适用于文件输入）

2.2.20 未知行数的输入

2.3 详解 row = list(map(int, input().split()))

2.3.0 list 和 map 在 Python 中不是关键字（keyword）！

2.3.1 input()：读入一行字符串

2.3.2 input().split() 会把它按空格切成列表：

2.3.3 map(函数, 可迭代对象) 表示把某个函数作用到列表每一个元素上。这里是：

2.3.4 为什么不能只写：

2.3.5 迭代器（iterator）的核心特点

2.3.6 迭代器的理解

2.3.7 为什么 map() 会返回迭代器？

3. print()输出函数

3.1 常见简单输出

3.2 自定义行末字符，需要添加end参数：

3.3 保留若干位小数，此时可以使用round()函数：

3.4 使用格式化字符串控制输出格式：

3.5 使用f-string控制输出格式（Python 3.6+，推荐使用)

3.6 补充：int() 转换规则

公告

2.2.17 文件读入多行或 input() 得到的字符串带 \n、空格、制表符，去掉换行和空格的写法：

数据结构里没有换行

方法 3：使用 `numpy` 库读取矩阵（适合更复杂的计算）