Python 作业题

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

1. 从键盘读取一个英文字符串，将其转换为大写，然后输出。
3. abc=input()
5. print(abc.upper())

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

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

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

1. import math
3. # 从键盘输入点A的坐标
4. a_x, a_y = input().split(",")
6. # 从键盘输入点B的坐标
7. b_x, b_y = input().split(",")
9. # 将坐标转换为浮点数
10. a_x = float(a_x)
11. a_y = float(a_y)
12. b_x = float(b_x)
13. b_y = float(b_y)
15. # 计算两点之间的距离
16. distance = math.sqrt((b_x - a_x) ** 2 + (b_y - a_y) ** 2)
18. # 输出结果，保留两位小数
19. print("{:.2f}".format(distance))

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

1. # 从键盘读入三个整数
2. num1 = int(input())
3. num2 = int(input())
4. num3 = int(input())
6. # 计算和与平均值
7. total = num1 + num2 + num3
8. average = total / 3
10. # 输出结果，和保留整数，平均值保留两位小数
11. print("{},{:.2f}".format(total, average))

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

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

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

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

1. 给定两个整型列表，找出不是两者共
2. 有的元素。这些元素不重复的放入新的
3. 列表，并升序排列。输出结果列表
4. nums1 = eval(input())
5. nums2 = eval(input())
6. nums3 = []
7. # 把不nums1中和nums2不重复的元素加入nums3
8. for x in nums1:
9. if x not in nums2:
10. if x not in nums3:
11. nums3.append(x)
12. # 把num2中的元素不重复的加入nums3
13. for x in nums2:
14. if x not in nums1:
15. if x not in nums3:
16. nums3.append(x)
17. nums3.sort()
18. print(nums3)

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

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

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

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

1. 已知一个列表中存放的是一些学生的姓名，
2. 另外一个列表存放的是学生对应的考试成绩。
3. 两个列表长度相同。要求，把姓名和对应的
4. 成绩进行组合，形成一个列表。该列表包含
5. 一个嵌套列表，每个子列都是姓名和对应的
6. 成绩。最后输出形成的新列表。
7. name = input().split(',')
8. grade = eval(input())
9. lst = []
10. for i in range(len(name)):
11. item = []
12. item.append(name[i])
13. item.append(grade[i])
14. lst.append(item)
15. print(lst)
16. 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 来创建一个嵌套列表，将姓名和对应的成绩添加到其中。

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

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

1. nums = eval(input())
2. zero =nums.count(0)
3. while nums.count(0) > 0:
4. nums.remove(0)
5. zeros = [0]*zero
6. nums =nums+zeros
7. print(nums)
8. 这段代码的功能是将列表 nums 中的所有零元素移到列表末尾。
10. 首先，使用 eval(input()) 获取输入的列表，并将其赋值给变量 nums。
12. 接下来，使用 nums.count(0) 统计列表中零元素的个数，并将结果赋值给变量 zero。
14. 然后，进入一个循环，条件是列表中仍然存在零元素，即 nums.count(0) > 0。在每次循环中，使用 nums.remove(0) 将列表中的一个零元素移除。
16. 接着，创建一个由零元素组成的列表 zeros，其长度为变量 zero 的值，并且每个元素都是零。
18. 最后，将原始列表 nums 和 zeros 列表拼接在一起，使用 nums = nums + zeros 将零元素添加到列表末尾。
20. 最终，使用 print(nums) 打印输出移动零元素后的列表 nums。

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

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

1. 读入一个正整数列表，每个正整数都只有一位。把这些列表里面的数字，按位数组织成一个最大的整数，每个数字占据一位，不能重复使用。然后输出这个数字。例如列表[1,2,3,4] 可以组成1234, 或者4321等多个整数。输出最大整数。
2. 【输入形式】
4. 一个包含一位自然数的列表
5. 【输出形式】
7. 整数
8. 【样例输入】
10. [0,1,2,3,2]
11. 【样例输出】
13. 32210
15. lst = eval(input())
17. # 对列表进行排序，按照数字从大到小的顺序
18. sorted_lst = sorted(lst, reverse=True)
20. # 将排序后的数字按位组织成一个整数
21. result = 0
22. for num in sorted_lst:
23. result = result * 10 + num
25. # 输出最大整数
26. print(result)

升序排列：

sorted_lst = sorted(lst, reverse=True) lst.sort(reverse=True)

1. nums = eval(input())
2. res = []
3. for num in nums:
4. if nums.count(num) == 1:
5. res.append(num)
6. res.sort()
7. if res:
8. print(",".join(str(i) for i in res))
9. else:
10. print("False")

 

1. def shift(lst):
2. tmp=lst[-1]
3. lst.insert(0,tmp)
4. lst.pop(-1)
5. list1 = input().split(",") #输入格式 1,2,3,4,5
6. shift(list1)
7. print(list1)
9. 这段代码定义了一个名为 shift 的函数，该函数接受一个列表作为参数，并执行以下操作：
11. tmp = lst[-1]：将列表 lst 的最后一个元素赋值给变量 tmp，即将列表的最后一个元素存储在临时变量中。
12. lst.insert(0, tmp)：将临时变量 tmp 插入到列表 lst 的第一个位置，即将最后一个元素移到列表的开头。
13. lst.pop(-1)：移除列表 lst 的最后一个元素，即删除原列表中的最后一个元素。

1. 【问题描述】加密数据。从键盘输入一段数字， 加密规则如下：对于每一个位置上的数字进行如下处理： 每位数字加上 5， 然后除以 10 得到的余数代替该数字， 再将第一位和最后一位交换，第二位与倒数第二位交换， 依此类推， 最后输出加密后的数字密码 。
2. 【输入形式】输入一行数字
3. 【输出形式】输出加密后的结果
4. 【样例输入】
6. 123
7. 【样例输出】
9. 876
11. nums_str=input()
12. new_nums=[]
13. for i in range(len(nums_str)):
14. new_nums.append((int(nums_str[i])+5)%10)
15. new_nums.reverse()
16. print("".join(str(x) for x in new_nums))

1. 【问题描述】折半查找。 1 个列表里存储了 20 个子列表， 各子列表内存储了学生的学号及姓名两个元素， 两个元素都是字符串类型。 现已知该 20 个学生子列表已按学号递增序排好序。请设计一个程序， 使用折半查找算法通过最少次数的比较找到指定学号的学生， 如果有， 输出这个学生的学号和姓名， 如果没有， 输出报告未找到该学生。 列表中存储数据为stu_list=
3. [['201801','zhangyi'],['201802','zhanger'],['201803','zhangsan'],['201804','zhangsi'],
5. ['201805','wangyi'],['201806','wanger'],['201807','wangsan'],['201808','wangsi'],
7. ['201809','liyi'],['201810','lier'],['201811','lisan'],['201812','lisi'],
9. ['201813','zhaoyi'],['201814','zhaoer'],['201815','zhaosan'],['201816','zhaosi'],
11. ['201817','zhouyi'],['201818','zhouer'],['201819','zhousan'],['201820','zhousi']]
13. 【输入形式】输入要查找的学生学号
14. 【输出形式】输出学号和姓名
15. 【样例输入】201800
16. 【样例输出】None
18. 【样例输入】201803
19. 【样例输出】201803zhangsan
21. 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']]
22. xuehao=eval(input())
23. xuehao=str(xuehao)
24. for i in range(len(ls)):
25. if xuehao in ls[i]:
26. print("".join(ls[i][x] for x in range(2) ))
27. # print(ls[i][0],end="")
28. #print(ls[i][1])
29. xuehao=int(xuehao)
30. if xuehao<201801 or xuehao>201820:
31. print('None')

1. 【问题描述】编写程序，从键盘输入一个数n，输出n以内的所有的回文素数。若n输入不合法（为小数或者负数），则输出提示：“illegal input”。
3. 回文素数是指一个数既是素数又是回文数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数称之为素数。例如131既是素数又是回文数。
5. 【输入形式】输入一个整数n（n>1）。
7. 【输出形式】以空格分隔输出n以内的所有的回文素数。若n输入不合法（为小数或负数），则输出提示“illegal input”
9. 【样例输入1】200
11. 【样例输出1】2 3 5 7 11 101 131 151 181 191
13. 【样例输入2】-4
15. 【样例输出2】illegal input
17. def is_prime(num):
18. if num < 2:
19. return False
20. for i in range(2, int(num ** 0.5) + 1):
21. if num % i == 0:
22. return False
23. return True
25. def is_palindrome(num):
26. return str(num) == str(num)[::-1]
28. def find_palindrome_primes(n):
29. if n <= 1 or not isinstance(n, int):
30. print("illegal input")
31. return
33. palindrome_primes = []
34. for i in range(2, n + 1):
35. if is_prime(i) and is_palindrome(i):
36. palindrome_primes.append(i)
38. print(" ".join(map(str, palindrome_primes)))
40. # 读取输入的整数n
41. n = eval(input())
43. # 查找n以内的回文素数并输出结果
44. find_palindrome_primes(n)

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

1. 【问题描述】从键盘输入两个整数n和m（要求ninput"。
3. 【输入形式】输入一行，内容为两个以空格分隔的整数，分别表示n和m。
5. 【输出形式】以空格分隔输出所有符合条件的三位数。
7. 【样例输入】1 4
9. 【样例输出】123 132 213 231 312 321
11. 【样例输入】2 4
13. 【样例输出】illegal input
15. 【样例输入】0 3
17. 【样例输出】102 120 201 210
20. n,m=input().split(' ')
21. n,m=int(n),int(m)
22. ls=[]
23. if type(n)!=int or type(m)!=int or n<0 or n>=10:
24. ls=[]
25. else:
26. for a in range(n,m):
27. sa=str(a)
28. for b in range(n,m):
29. sb=str(b)
30. for c in range(n,m):
31. sc=str(c)
32. sabc=sa+sb+sc
33. if int(sa)!=0 and sa!=sb and sb!=sc and sc!=sa and len(sabc)==3 and sabc not in ls:
34. ls.append(sabc)
35. if ls==[]:
36. print('illegal input')
37. else:
38. print(' '.join(x for x in ls))

ellf

1. 【问题描述】
3. 输入一行字符（不能输入中文字符），分别统计出该字符串英文字符、空格、数字和其他字符的个数
5. 【输入形式】
7. 字符串
9. 【输出形式】
11. 英文字符个数 空格个数 数字字符个数 其他字符个数
13. 【样例输入】
15. abcd 1 2 3 4!@#$$%^
17. 【样例输出】
19. 4 4 4 7
21. 【样例说明】
23. 输出数字之间用空格隔开
25. string = input()
27. letter_count = 0
28. space_count = 0
29. digit_count = 0
30. other_count = 0
32. for char in string:
33. if (char >= 'a' and char <= 'z') or (char >= 'A' and char <= 'Z'):
34. letter_count += 1
35. elif char == ' ':
36. space_count += 1
37. elif char >= '0' and char <= '9':
38. digit_count += 1
39. else:
40. other_count += 1
42. print(letter_count, space_count, digit_count, other_count)
43. 或者
44. import numbers
45. zf=input()
46. yw=0
47. kg=0
48. sz=0
49. qt=len(zf)
50. for i in zf:
51. if i.isalpha():
52. yw=yw+1
53. elif i.isdigit():
54. sz=sz+1
55. elif i.isspace():
56. kg=kg+1
57. qt=qt-yw-sz-kg
58. print(yw,kg,sz,qt,end=" ")

1. 【问题描述】输入一个整数，输出小于等于该整数的所有水仙花数，每行输出一个，若没有水仙花数则输出“none”
3. “3位水仙花数”是指一个三位整数，其各位数字的3次方和等于该数本身。例如：ABC是一个“3位水仙花数”，则：A的3次方＋B的3次方＋C的3次方 = ABC。
5. n = int(input())
7. narcissistic_numbers = []
9. for num in range(100, n + 1):
10. # 将数字转换为字符串，以便按位提取数字
11. digits = str(num)
13. # 计算每位数字的立方和
14. sum_of_cubes = 0
15. for digit in digits:
16. sum_of_cubes += int(digit) ** 3
18. # 如果立方和等于原数字，则将其添加到水仙花数列表中
19. if sum_of_cubes == num:
20. narcissistic_numbers.append(num)
22. # 按照要求格式输出结果
23. if len(narcissistic_numbers) > 0:
24. for number in narcissistic_numbers:
25. print(number)
26. else:
27. print("none")

1. lst = eval(input())
2. counts = [0] * 26
3. for i in lst:
4. for j in i:
5. counts[ord(j)-ord('a')]+=1
6. for i in range(26):
7. if counts[i]>0:
8. print(chr(ord('a')+i),counts[i],sep=',')
10. 让我们逐行解读这段代码：
12. lst = eval(input())：这行代码用于从用户输入中获取一个字符串列表，并将其赋值给变量lst。eval()函数用于评估用户输入的字符串作为Python代码，并返回结果。
14. counts = [0] * 26：这行代码创建了一个长度为26的列表counts，用于存储每个字母的出现次数。初始时，所有字母的次数都设为0。
16. for i in lst:：这是一个外部循环，遍历字符串列表中的每个字符串。
18. for j in i:：这是一个内部循环，遍历当前字符串中的每个字符。
20. counts[ord(j)-ord('a')] += 1：这行代码根据当前字符的ASCII码值计算出其在列表counts中的索引，并将对应位置的次数加1。ord(j)返回字符j的ASCII码值，ord('a')返回小写字母a的ASCII码值。通过这样的计算，我们可以将每个字母映射到列表counts中的对应位置。
22. for i in range(26):：这是一个循环，遍历列表counts中的索引。
24. if counts[i] > 0:：使用条件语句检查当前字母的出现次数是否大于0，即是否出现过。
26. print(chr(ord('a')+i), counts[i], sep=',')：这行代码根据索引i计算出对应的字母，并将字母和对应的次数以逗号分隔的形式输出。chr(ord('a')+i)将索引i转换为对应的小写字母。