01-Pyhton算法入门-简单输入输出

知白286

379人浏览 · 2026-03-19 13:49:29

知白286 · 2026-03-19 13:49:29 发布

1.打印字符串

import sys
print("hello,Python")

2.单组_A+B

给定两个整数 a 和 b ，请你求出 a+b 的值。

import sys
s = list(input().split())
print(int(S[0])+int(S[1]))

3.多组_A+B_EOF形式

给定若干组测试数据，读取至文件末尾为止。
每组数据有两个整数 a 和 b ，请你求出 a+b 的值。

#初版
import sys
for num in sys.stdin:
    s = list(num.split())
    if not num:
        continue
    print (int(s[0])+int(s[1]))
#更安全更健壮
import sys
for num in sys.stdin:
    num = num.strip()
    s = num.split() #str.split() 方法在 Python 中本身就直接返回一个列表（list）
    if not num:
        continue
    if len(s) >=2:
        print (int(s[0])+int(s[1]))

sys.stdin 是 Python 编程语言中 sys 模块提供的一个标准对象，代表标准输入（Standard Input）。

常见用法：
读取所有输入：sys.stdin.read() 一次性读取直到文件结束符（EOF）。
逐行读取：sys.stdin 是可迭代的，可以直接用于 for line in sys.stdin: 循环中，每次读取一行。
读取一行：sys.stdin.readline() 读取单行。
与 input() 的区别：
input()：读取一行，自动去掉末尾的换行符，如果遇到 EOF 会抛出 EOFError。适合交互式程序。
sys.stdin：更底层，保留换行符（除非手动 strip），读取效率通常比循环调用 input() 更高，适合处理大量数据或非交互式脚本。

4.多组_A+B_T组形式

给定 t 组测试数据。
每组数据有两个整数 a 和 b ，请你求出 a+b 的值。

import sys
for num in sys.stdin:
    num = num.strip()
    s = num.split()
    if not num:
        continue
    if len(s) ==2:
        print (int(s[0])+int(s[1]))

5.多组_A+B_零尾模式

给定若干组测试数据，最后一组数据为 0 0 ，作为输入的结尾。
每组数据有两个整数 a 和 b ，请你求出 a+b 的值。

import sys

for line in sys.stdin:
    line = line.strip()
    s = line.split()
    if len(s) != 2:
        continue
    a = int(s[0])
    b = int(s[1])
    if a==0 and b==0:
        break
    print(a+b)

6.单组_一维数组

给定一个长度为 n 的正整数数组 a ，第 i 个元素的值为 ai 。
请你求出数组元素之和。

#初版，忽略了输入的n
import sys

for line in sys.stdin:
    line = line.strip()
    a = line.split()
    if len(a) <= 1:
        continue
    num = 0
    for i in range(len(a)):
        c = int(a[i])
        num += c
    print(num)
#更优雅、优雅的写法，一定要先读n，且可以做个判断，没有n就不走后面的
import sys
n_line = sys.stdin.readline()
if not n_line:
    exit()
line = sys.stdin.readline()
line = line.strip()
a = line.split()
print(sum(map(int, a)))

map(function, iterable, ...)

function：你要应用的函数（可以是内置函数如 int，也可以是你自己定义的函数，或者是 lambda 匿名函数）。
iterable：要被处理的数据集合（列表、元组、字符串、或者像 sys.stdin.read().split() 产生的列表）。
返回值：一个 map object (迭代器)。
- ⚠️ 注意：在 Python 3 中，map 不会直接返回一个列表！它返回的是一个“懒惰”的迭代器。只有当你遍历它（如在 for 循环中）或强制转换它（如用 list() 或 sum()）时，它才会真正执行计算。

7.多组_一维数组_T组形式

给定 t 组询问，每次询问给出一个长度为 n 的正整数数组 a ，第 i 个元素的值为 ai 。
请你分别求出每个数组的元素之和。

import sys
t_line = sys.stdin.readline()
if not t_line:
    exit()
for i in range(int(t_line)):
    n_line = sys.stdin.readline()
    if not n_line:
        exit()
    line = sys.stdin.readline()
    line = line.strip()
    a = line.split()
    print(sum(map(int, a)))

不必要的 strip()：split() 默认就会忽略首尾空白和换行符

8.单组_二维数组

给定一个 n 行 m 列的二维正整数数组 {ai,j}，其中1≦i≦n，1≦j≦m，且1≦ai,j≦10的九次方。
请计算数组中所有元素之和

#初版
import sys
s = sys.stdin.readline().split()
n = int(s[0])
total_num = 0
for i in range(n):
    num_line = sys.stdin.readline().split()
    sum_num = sum(map(int,num_line))
    total_num += sum_num
print(total_num)
#更简洁高效的写法(去除前两个元素直接求和)
import sys
data = sys.stdin.read().split()
print(sum(map(int, data[2:])))

9.多组_二维数组_T组形式

给定 t 组询问，每次询问给出一个 n 行 m 列的二维正整数数组 a ，第 i 行第 j 列元素的值为 ai,j 。
请你分别求出每个数组的元素之和。

#初版（根据t进行了行列二重循环）
import sys
t = sys.stdin.readline()
for _ in range(int(t)):
    n, m = map(int, input().split())
    total = 0
    for i in range(n):       
        row = list(map(int, input().split()))
        for x in row:        
            total += x
    print(total)
#更高效
import sys

def solve():
    input_data = sys.stdin.read().split()
    
    if not input_data:
        return
    iterator = iter(input_data)
    
    try:
        t = int(next(iterator))
        
        for _ in range(t):
            n = int(next(iterator))
            m = int(next(iterator))
            
            count = n * m
            from itertools import islice
            current_sum = sum(map(int, islice(iterator, count)))
            print(current_sum)
            
    except StopIteration:
        pass

if __name__ == '__main__':
    solve()

迭代器（Iterator）：

在 Python 中，迭代器必须实现两个方法：
__iter__(): 返回迭代器本身。
__next__(): 返回下一个元素；如果没有元素了，抛出 StopIteration。

Iterated Slice（迭代切片）：“专门给迭代器用的切片刀”。

islice(iterable, stop): 取前 stop 个（相当于 [:stop]）。

islice(iterable, start, stop): 从 start 取到 stop（相当于 [start:stop]）。

islice(iterable, start, stop, step): 带步长（相当于 [start:stop:step]）。

try...except 结构主要用于“防御性编程”

只要涉及外部输入（用户键盘、文件、网络），永远假设它是错的，用 try 包住。

当某个异常代表“任务完成”或“到达边界”时，用 try 来优雅地跳出循环。

操作文件、网络连接、数据库时，极易发生不可控错误（文件不存在、网断了、权限不够）。

在某些复杂计算中，个别数据出错不影响大局，你只想跳过坏数据，处理好的数据。

入口保护：

if __name__ == '__main__':

10.单组_字符串

给定一个长度为 n 的字符串 s ，请你将其倒置，然后输出。

import sys
n = sys.stdin.readline()
m = sys.stdin.readline().strip()
print(m[::-1])

11.多组_字符串_T组形式

给定 t 组询问，每次给出一个长度为 n 的字符串 s ，请你将其倒置，然后输出。

import sys
def solve():
    input_data = sys.stdin.read().split()
    
    if not input_data:
        return
    iterator = iter(input_data)
    try:
        t = int(next(iterator))
        
        for _ in range(t):
            n = int(next(iterator))
            print(next(iterator)[::-1])
    except StopIteration:
        pass
if __name__ == '__main__':
    solve()

12.单组_二维字符数组

给定一个 n 行 m 列的二维字符数组 a ，第 i 行第 j 列元素的值为ai,j 。
请你对行和列都倒置，然后输出之。

import sys
def solve():
    input_data = sys.stdin.read().split()
    
    if not input_data:
        return
    iterator = iter(input_data)
    m = int(next(iterator))
    n = int(next(iterator))
    remaining_strings = list(iterator)
    all_chars = []
    for s in remaining_strings:
        all_chars.extend(list(s))
    if len(all_chars) < m*n:
        return
    for r in range(m-1,-1,-1):
        start = r*n
        end = start+n
        row = all_chars[start:end]
        new_row = row[::-1]
        print("".join(new_row))
if __name__== '__main__':
    solve()

13.多组_带空格的字符串_T组形式

给定 t 组询问，每次给出一个长度为 n 的带空格的字符串 s ，请你去掉空格之后，将其倒置，然后输出。

import sys
t = int(sys.stdin.readline())
for r in range(t):
    n = int(sys.stdin.readline())
    row  = sys.stdin.readline().split()
    all_chars = []
    for s in row:
        all_chars.extend(list(s))
    new_row = all_chars[::-1]
    print ("".join(new_row))

列表转字符串：
"".join()

14.单组_保留小数位数

给定一个小数 n ，请你保留 33 位小数后输出。
如果原来的小数位数少于 33 ，需要补充 00 。
如果原来的小数位数多于 33 ，需要四舍五入到 33 位。

import sys
num = float(sys.stdin.readline())
print(f"{num:.3f}")

15.单组_补充前导零

给定一个正整数 n ，请你保留 99 个数位，然后输出。
如果数位少于 99 个，那么需要补充前导零。

import sys
num = int(sys.stdin.readline().strip())
print(f"{num:09d}")

f-string

需求	格式字符串	示例代码	结果	说明
仅输出整数	`{:d}`	`f"{num:d}"`	`31`	默认行为，通常可省略 `:d`
补空格对齐	`:10d`	`f"{num:10d}"`	`31`	总宽10位，前面补8个空格
补零对齐	`:010d`	`f"{num:010d}"`	`0000000031`	总宽10位，前面补8个0
右对齐(默认)	`:10d`	`f"{num:10d}"`	`31`	数字靠右
左对齐	`:<10d`	`f"{num:<10d}"`	`31`	数字靠左，后面补空格
居中对齐	`:^10d`	`f"{num:^10d}"`	`31`	数字居中，两边补空格
居中补零	`:^010d`	`f"{num:^010d}"`	`0000310000`	数字居中，两边补0

16.单组_spj判断YES与NO

给定一个正整数 n 。
如果 n 是奇数，输出 YES 。
如果 n 是偶数，输出 NO 。
你可以输出任意大小写形式的 YES 和 NO 。
比如， yes , Yes , yEs 都会被视为 YES 。

import sys

num = int(sys.stdin.read().strip())
if num % 2 == 1:
    print("YES")
else:
    print("NO")

17.单组_spj判断浮点误差

给定一个圆的半径 r ，请你求出该圆的面积。
保证半径 r 是整数。
如果你的答案和标准答案的误差不超过 10的负三次方，即可通过本题。

from math import pi
import sys
num = int(sys.stdin.read().strip())
sq = (num*num)*pi
print(f"{sq:.6f}")

18.单组_spj判断数组之和

给定两个整数 n 和 m ，请你构造一个长度为 n 的正整数数组，使得其元素之和为 m 。
保证有n≤m 。

import sys

def solve():

    try:
        line = sys.stdin.readline()
        if not line:
            return
        parts = list(map(int, line.split()))
        if len(parts) != 2:
            return
        n, m = parts
    except ValueError:
        return
    result = []
    if n == 1:
        result = [m]
    else:
        result = [1] * (n - 1) + [m - (n - 1)]
    print(" ".join(map(str, result)))
if __name__ == "__main__":
    solve()