Python作业题解析及答案分享

保留n位小数 {:.nf}. 千万别忘了.

从键盘读取一个英文字符串，将其转换为大写，然后输出。

abc=input()

print(abc.upper())

输入平面上两个点A和B的坐标，(x1,y1)和(x2,y2)，完成如下任务：

1.要求使用者输入A,B的平面坐标共4个值;

2.计算并输出两点之间的距离，保留2位小数

import math

# 从键盘输入点A的坐标
a_x, a_y = input().split(",")

# 从键盘输入点B的坐标
b_x, b_y = input().split(",")

# 将坐标转换为浮点数
a_x = float(a_x)
a_y = float(a_y)
b_x = float(b_x)
b_y = float(b_y)

# 计算两点之间的距离
distance = math.sqrt((b_x - a_x) ** 2 + (b_y - a_y) ** 2)

# 输出结果，保留两位小数
print("{:.2f}".format(distance))

x1,y1 = map(int,input().split(','))
x2,y2 = map(int,input().split(','))
d = ((x1-x2)**2+(y1-y2)**2)**0.5
print(f'{d:.2f}')

# 从键盘读入三个整数
num1 = int(input())
num2 = int(input())
num3 = int(input())

# 计算和与平均值
total = num1 + num2 + num3
average = total / 3

# 输出结果，和保留整数，平均值保留两位小数
print("{},{:.2f}".format(total, average))

读入一个整数列表和正整数n(n>1)，
把列表中每个元素重复n次，并对每个
元素进行平方形成新的列表，最后去除
列表中的重复元素。打印输出新列表。
ls = eval(input())
n = eval(input())
# 重复列表元素n次
ls2=ls*n
ls3 = [x*x for x in ls2]
# 下面代码去除重复元素
ls4=[]
for x in ls3:
   if x not in ls4:
       ls4.append(x)
print(ls4)

给定长度为2n的自然数列表nums，
把这些数分成n对，把每一对的最小值
加起来（不同的分法，其和可能不同）
，输出最小值和的最大值。
def maxsum(list1):
    list1.sort()
    sum=0
    for i in range(len(list1)):
        if i%2==0:
            sum=sum+list1[i]
return sum
nums = eval(input())
v = maxsum(nums)#调用自定义函数
print(v)

编写函数获得第n项斐波那契数列的
值。斐波那契数列前10项如下：[1, 1, 2, 
3, 5, 8, 13, 21, 34, 55]。第1项为1，第二
项为1，从第三项开始，每一项等于前两
项之和。
def Fibonacci(num,n):
    if(n<2):
        return 1
    for i in range(2,n):
        num.append(num[i-1]+num[i-2])
    return num[-1]#num[-1] 是对列表 num 的最后一个元素的引用。在 Python 中，使用负数索引可以从列表的末尾开始计数。
num = [1, 1]
n = int(input())
print(Fibonacci(num, n))

range(n, m, 2) 是一个使用步长为 2 的 range 对象，生成从 n（包含）到 m（不包含）的整数序列。

给定两个整型列表，找出不是两者共
有的元素。这些元素不重复的放入新的
列表，并升序排列。输出结果列表
nums1 = eval(input())
nums2 = eval(input())
nums3 = []
# 把不nums1中和nums2不重复的元素加入nums3
for x in nums1:
    if x not in nums2:
        if x not in nums3:
            nums3.append(x)
# 把num2中的元素不重复的加入nums3
for x in nums2:
    if x not in nums1:
        if x not in nums3:
            nums3.append(x)
nums3.sort()
print(nums3)

读入一个大小为n的列表，找出其中的多
数元素。多数元素是指在列表中出现次数大
于n//2的元素（每个列表最多一个多数元素
）。根据代码框架编写一个函数。
def search(nums):
    for n in nums:
        if nums.count(n)>len(nums)//2:
            return n
    return False
nums = eval(input())
y = search(nums)
print(y)

n // 2 是 Python 中的整数除法运算符，用于计算 n 除以 2 的整数部分。

具体来说，// 运算符执行整数除法，即将除法结果向下取整到最接近的整数。它会返回一个整数值，而不是浮点数。

例如，对于整数 n 的值为 7，n // 2 的结果为 3，因为 7 除以 2 的整数部分是 3。

已知一个列表中存放的是一些学生的姓名，
另外一个列表存放的是学生对应的考试成绩。
两个列表长度相同。要求，把姓名和对应的
成绩进行组合，形成一个列表。该列表包含
一个嵌套列表，每个子列都是姓名和对应的
成绩。最后输出形成的新列表。
name = input().split(',')
grade = eval(input())
lst = []
for i in range(len(name)):
    item = []
    item.append(name[i])
    item.append(grade[i])
    lst.append(item)
print(lst)
lst = [[name[i],grade[i]] for i in range(len(name))]

for i in range(len(name)) 这段代码是一个循环，用于遍历姓名列表 name 的索引。

len(name) 返回姓名列表 name 的长度，即列表中元素的个数。

range(len(name)) 创建了一个整数序列，从 0 到 len(name)-1，用于遍历 name 列表的索引。

在每次循环中，变量 i 代表当前的索引值，可以用来访问列表中的元素。通过 name[i] 可以获取到 name 列表中索引为 i 的元素。

所以，这段代码的作用是遍历姓名列表 name 中的每个元素，通过索引 i 来访问每个元素。在你的代码中，循环体内部使用该索引 i 来创建一个嵌套列表，将姓名和对应的成绩添加到其中。

读入一个列表lst和正整数n和m，然后
删除n~m之间的元素，不包括m位置的元素，
其中n小于或者等于m。如果输入的n和m不
在列表lst的下标范围内，则输出"error"。
lst=eval(input())
n,m=eval(input())
if len(lst)-1>=m>=n>=0:
    lst[n:m]=[]
    print(lst)
else:
    print("error")

输入一个由字符串构成的列表和两个整数n
和m（n和m在输入列表的下标范围以内），交
换其中两个元素的值，打印输出交换后的列表。
lst = list(input().split())
n,m = input().split()
n = int(n)
m = int(m)
lst[n],lst[m] = lst[m],lst[n]#python NB!
print(lst)

nums = eval(input())
zero =nums.count(0)
while nums.count(0) > 0:
    nums.remove(0)
zeros = [0]*zero
nums =nums+zeros
print(nums)
这段代码的功能是将列表 nums 中的所有零元素移到列表末尾。

首先，使用 eval(input()) 获取输入的列表，并将其赋值给变量 nums。

接下来，使用 nums.count(0) 统计列表中零元素的个数，并将结果赋值给变量 zero。

然后，进入一个循环，条件是列表中仍然存在零元素，即 nums.count(0) > 0。在每次循环中，使用 nums.remove(0) 将列表中的一个零元素移除。

接着，创建一个由零元素组成的列表 zeros，其长度为变量 zero 的值，并且每个元素都是零。

最后，将原始列表 nums 和 zeros 列表拼接在一起，使用 nums = nums + zeros 将零元素添加到列表末尾。

最终，使用 print(nums) 打印输出移动零元素后的列表 nums。

输入一个整数列表和整数n(n可以是负数）和正整
数m，从该列表中选择第n个元素，把该元素重复m次，
然后放到列表的尾端，最后输出列表。如果输入的n值不
在列表下标范围之内，则输出"error"
nums = list(eval(input()))
n,m = eval(input())
nlen = len(nums)
if n>= nlen or n < -1*nlen:
    print("error")
else:
    append_l =[nums[n]]*m
    nums = nums+append_l
    print(nums)

读入一个整数列表，输出删除最大元素和最小
元素后的列表。最大元素和最小元素可能有多个。
nums = eval(input())
max_num = max(nums)
min_num = min(nums)
tmp = nums.copy()
for num in nums:
    if num == max_num or num == min_num:
        tmp.remove(num)
print(tmp)

读入一个正整数列表，每个正整数都只有一位。把这些列表里面的数字，按位数组织成一个最大的整数，每个数字占据一位，不能重复使用。然后输出这个数字。例如列表[1,2,3,4] 可以组成1234, 或者4321等多个整数。输出最大整数。
【输入形式】

一个包含一位自然数的列表
【输出形式】

整数
【样例输入】

[0,1,2,3,2]
【样例输出】

32210

lst = eval(input())

# 对列表进行排序，按照数字从大到小的顺序
sorted_lst = sorted(lst, reverse=True)

# 将排序后的数字按位组织成一个整数
result = 0
for num in sorted_lst:
    result = result * 10 + num

# 输出最大整数
print(result)

升序排列：

sorted_lst = sorted(lst, reverse=True)

lst.sort(reverse=True)

nums = eval(input())
res = []
for num in nums:
    if nums.count(num) == 1:
        res.append(num)
res.sort()
if res:
    print(",".join(str(i) for i in res))
else:
    print("False")

def shift(lst):
    tmp=lst[-1]
    lst.insert(0,tmp)
    lst.pop(-1)
list1 = input().split(",") #输入格式 1,2,3,4,5
shift(list1)
print(list1)
 
这段代码定义了一个名为 shift 的函数，该函数接受一个列表作为参数，并执行以下操作：

tmp = lst[-1]：将列表 lst 的最后一个元素赋值给变量 tmp，即将列表的最后一个元素存储在临时变量中。
lst.insert(0, tmp)：将临时变量 tmp 插入到列表 lst 的第一个位置，即将最后一个元素移到列表的开头。
lst.pop(-1)：移除列表 lst 的最后一个元素，即删除原列表中的最后一个元素。

【问题描述】加密数据。从键盘输入一段数字， 加密规则如下：对于每一个位置上的数字进行如下处理： 每位数字加上 5， 然后除以 10 得到的余数代替该数字， 再将第一位和最后一位交换，第二位与倒数第二位交换， 依此类推， 最后输出加密后的数字密码 。
【输入形式】输入一行数字
【输出形式】输出加密后的结果
【样例输入】

123
【样例输出】

876

nums_str=input()
new_nums=[]
for i in range(len(nums_str)):
    new_nums.append((int(nums_str[i])+5)%10)
new_nums.reverse()
print("".join(str(x) for x in new_nums))    

【问题描述】折半查找。 1 个列表里存储了 20 个子列表， 各子列表内存储了学生的学号及姓名两个元素， 两个元素都是字符串类型。 现已知该 20 个学生子列表已按学号递增序排好序。请设计一个程序， 使用折半查找算法通过最少次数的比较找到指定学号的学生， 如果有， 输出这个学生的学号和姓名， 如果没有， 输出报告未找到该学生。 列表中存储数据为stu_list=

[['201801','zhangyi'],['201802','zhanger'],['201803','zhangsan'],['201804','zhangsi'],

['201805','wangyi'],['201806','wanger'],['201807','wangsan'],['201808','wangsi'],

['201809','liyi'],['201810','lier'],['201811','lisan'],['201812','lisi'],

['201813','zhaoyi'],['201814','zhaoer'],['201815','zhaosan'],['201816','zhaosi'],

['201817','zhouyi'],['201818','zhouer'],['201819','zhousan'],['201820','zhousi']]

【输入形式】输入要查找的学生学号
【输出形式】输出学号和姓名
【样例输入】201800
【样例输出】None

【样例输入】201803
【样例输出】201803zhangsan

ls=[['201801','zhangyi'],['201802','zhanger'],['201803','zhangsan'],['201804','zhangsi'],['201805','wangyi'],['201806','wanger'],['201807','wangsan'],['201808','wangsi'],['201809','liyi'],['201810','lier'],['201811','lisan'],['201812','lisi'],['201813','zhaoyi'],['201814','zhaoer'],['201815','zhaosan'],['201816','zhaosi'],['201817','zhouyi'],['201818','zhouer'],['201819','zhousan'],['201820','zhousi']]
xuehao=eval(input())
xuehao=str(xuehao)
for i in range(len(ls)):
    if xuehao in ls[i]:
        print("".join(ls[i][x] for x in range(2) ))
       # print(ls[i][0],end="")
        #print(ls[i][1])
xuehao=int(xuehao)
if xuehao<201801 or xuehao>201820:
        print('None')

【问题描述】编写程序，从键盘输入一个数n，输出n以内的所有的回文素数。若n输入不合法（为小数或者负数），则输出提示：“illegal input”。

回文素数是指一个数既是素数又是回文数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数称之为素数。例如131既是素数又是回文数。

【输入形式】输入一个整数n（n>1）。

【输出形式】以空格分隔输出n以内的所有的回文素数。若n输入不合法（为小数或负数），则输出提示“illegal input”

【样例输入1】200

【样例输出1】2 3 5 7 11 101 131 151 181 191

【样例输入2】-4

【样例输出2】illegal input

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            return False
    return True

def is_palindrome(num):
    return str(num) == str(num)[::-1]

def find_palindrome_primes(n):
    if n <= 1 or not isinstance(n, int):
        print("illegal input")
        return

    palindrome_primes = []
    for i in range(2, n + 1):
        if is_prime(i) and is_palindrome(i):
            palindrome_primes.append(i)

    print(" ".join(map(str, palindrome_primes)))

# 读取输入的整数n
n = eval(input())

# 查找n以内的回文素数并输出结果
find_palindrome_primes(n)

判断类型 isinstance(n, int) 或者 type(n)==int

【问题描述】从键盘输入两个整数n和m（要求n<m），编程求出由n到m(不包含m)中的整数组合而成的所有不含重复数字的三位数。若n和m的输入不合法或者没有符合条件的三位数则提示输出“illegal input"。

【输入形式】输入一行，内容为两个以空格分隔的整数，分别表示n和m。

【输出形式】以空格分隔输出所有符合条件的三位数。

【样例输入】1 4

【样例输出】123 132 213 231 312 321

【样例输入】2 4

【样例输出】illegal input

【样例输入】0 3

【样例输出】102 120 201 210


n,m=input().split(' ')
n,m=int(n),int(m)
ls=[]
if type(n)!=int or type(m)!=int or n<0 or n>=10:
    ls=[]
else:
    for a in range(n,m):
        sa=str(a)
        for b in range(n,m):
            sb=str(b)
            for c in range(n,m):
                sc=str(c)
                sabc=sa+sb+sc
                if int(sa)!=0 and sa!=sb and sb!=sc and sc!=sa and len(sabc)==3  and sabc not in ls:
                    ls.append(sabc)
if ls==[]:
    print('illegal input')
else:
    print(' '.join(x for x in ls))

ellf

【问题描述】

输入一行字符（不能输入中文字符），分别统计出该字符串英文字符、空格、数字和其他字符的个数

【输入形式】

字符串

【输出形式】

英文字符个数 空格个数 数字字符个数 其他字符个数

【样例输入】

abcd 1 2 3 4!@#$$%^

【样例输出】

4 4 4 7

【样例说明】

输出数字之间用空格隔开

string = input()

letter_count = 0
space_count = 0
digit_count = 0
other_count = 0

for char in string:
    if (char >= 'a' and char <= 'z') or (char >= 'A' and char <= 'Z'):
        letter_count += 1
    elif char == ' ':
        space_count += 1
    elif char >= '0' and char <= '9':
        digit_count += 1
    else:
        other_count += 1

print(letter_count, space_count, digit_count, other_count)
或者
import numbers
zf=input()
yw=0
kg=0
sz=0
qt=len(zf)
for i in zf:
    if i.isalpha():
        yw=yw+1
    elif i.isdigit():
        sz=sz+1
    elif i.isspace():
        kg=kg+1
qt=qt-yw-sz-kg
print(yw,kg,sz,qt,end=" ")

【问题描述】输入一个整数，输出小于等于该整数的所有水仙花数，每行输出一个，若没有水仙花数则输出“none”

“3位水仙花数”是指一个三位整数，其各位数字的3次方和等于该数本身。例如：ABC是一个“3位水仙花数”，则：A的3次方＋B的3次方＋C的3次方 = ABC。 

n = int(input())

narcissistic_numbers = []

for num in range(100, n + 1):
    # 将数字转换为字符串，以便按位提取数字
    digits = str(num)

    # 计算每位数字的立方和
    sum_of_cubes = 0
    for digit in digits:
        sum_of_cubes += int(digit) ** 3

    # 如果立方和等于原数字，则将其添加到水仙花数列表中
    if sum_of_cubes == num:
        narcissistic_numbers.append(num)

# 按照要求格式输出结果
if len(narcissistic_numbers) > 0:
    for number in narcissistic_numbers:
        print(number)
else:
    print("none")

lst = eval(input())
counts = [0] * 26
for i in lst:
    for j in i:
        counts[ord(j)-ord('a')]+=1
for i in range(26):
    if counts[i]>0:
        print(chr(ord('a')+i),counts[i],sep=',')

让我们逐行解读这段代码：

lst = eval(input())：这行代码用于从用户输入中获取一个字符串列表，并将其赋值给变量lst。eval()函数用于评估用户输入的字符串作为Python代码，并返回结果。

counts = [0] * 26：这行代码创建了一个长度为26的列表counts，用于存储每个字母的出现次数。初始时，所有字母的次数都设为0。

for i in lst:：这是一个外部循环，遍历字符串列表中的每个字符串。

for j in i:：这是一个内部循环，遍历当前字符串中的每个字符。

counts[ord(j)-ord('a')] += 1：这行代码根据当前字符的ASCII码值计算出其在列表counts中的索引，并将对应位置的次数加1。ord(j)返回字符j的ASCII码值，ord('a')返回小写字母a的ASCII码值。通过这样的计算，我们可以将每个字母映射到列表counts中的对应位置。

for i in range(26):：这是一个循环，遍历列表counts中的索引。

if counts[i] > 0:：使用条件语句检查当前字母的出现次数是否大于0，即是否出现过。

print(chr(ord('a')+i), counts[i], sep=',')：这行代码根据索引i计算出对应的字母，并将字母和对应的次数以逗号分隔的形式输出。chr(ord('a')+i)将索引i转换为对应的小写字母。