【学习笔记】Python语言基础与应用（陈斌）--上机编程作业
记录编程结果，方便回顾。
附上课程连接：Python语言基础与应用
目录
- 章节三：数据类型（一）
- 章节四：数据类型（二）
- 章节五：计算与控制流（一）
- 章节六：计算与控制流（二）
- 章节七：基本扩展模块
- 章节八：高级特性（一）：面向对象
章节三：数据类型（一）
- 给定一个字符串S，要求把S的前k个字符移动到S的尾部，如把字符串“abcdef”前面的2个字符‘a’、‘b’移动到字符串的尾部，得到新字符串“cdefab”，称作字符串循环左移k位。
输入一个字符串和一个非负整数N，要求将字符串循环左移N次。
s = str(input())
n = int(input())
first_part = s[:n]
second_part = s[n:]
new_n = second_part + first_part
print(new_n)
- 输入直角三角形两直角边a,b的值，输出斜边上的高。
a = int(input())
b = int(input())
square = a*b
c = (a**2 + b**2)**0.5
h = square/c
print(round(h, 2))
- 计算字符串最后一个单词的长度，单词以空格隔开。
s = str(input())
words = s.split()
print(len(words[-1]))
- 接受一个由字母和数字组成的字符串，和一个字符，然后输出输入的字符串中含有该字符的个数。不区分大小写。
s = str(input())
ch = s[-1].lower()
words = s[:-2].lower()
i = 0
for word in words:
if word == ch:
i += 1
print(i)
- 给出两个整数，输出他们的和
n_1 = int(input())
n_2 = int(input())
sum = n_1 + n_2
print(sum)
- 给出一个圆的半径，求出圆的周长和面积
n = int(input())
pi = 3.14159
square = round((pi*n**2), 4)
round = round((2*pi*n), 4)
print(round, square)
- 由三角形的三边长，求其面积。
规定：输入的三条边一定能构成三角形，不用进行判定。
a = int(input())
b = int(input())
c = int(input())
p = (a+b+c)/2
s = (p*(p-a)*(p-b)*(p-c))**0.5
print('%.2f'%s)
- 给出一个等差数列的前两项a1，a2，求第n项是多少
a1 = int(input())
a2 = int(input())
n = int(input())
mines = a2 - a1
result = a1 + mines*(n-1)
print(result)
章节四：数据类型（二）
- 输入两个列表alist和blist，要求列表中的每个元素都为正整数且不超过10；
合并alist和blist，并将重复的元素去掉后输出一个新的列表clist。
alist=list(map(int, input().split()))
blist=list(map(int, input().split()))
aset = set((alist + blist))
print(sorted(list(aset)))
- 输入一个列表，要求列表中的每个元素都为正整数且列表包含的元素个数为偶数；
将列表中前一半元素保存至字典的第一个键值1中，后一半元素保存至第二个键值2中。
alist=list(map(int, input().split()))
dic = {}
lenth = len(alist)
mid = lenth//2
dic['1'] = list(alist[:mid])
dic['2'] = list(alist[mid:])
print(dic)
- 输入一个列表，将其反转后输出新的列表。
alist=list(map(int, input().split()))
alist.reverse()
print(alist)
- 输入一个列表，要求列表中的每个元素都为整数；
将列表中的所有元素按照它们的绝对值大小进行排序，绝对值相同的还保持原来的相对位置，打印排序后的列表（绝对值大小仅作为排序依据，打印出的列表中元素仍为原列表中的元素）。
alist=list(map(int, input().split()))
alist.sort(key=abs)
print(alist)
章节五：计算与控制流（一）
- 水仙花数是指一个n位数 (n≥3)，它的每个位上的数字的n次幂之和等于它本身。
例如：153是一个“水仙花数”，因为 153 是个 3位数，而13+53+3**3==153。
输入一个正整数max，输出100到max之间的所有水仙花数（包括max）。
max = int(input())
num = 100
while num <= max:
n = len(str(num))
x_list = list(str(num))
sumnum = 0
for x in x_list:
xn = int(x)**n
sumnum += xn
if sumnum == num:
print(num)
num += 1
else:
num += 1
- 输入两个字符串，输出两个字符串集合的并集。为保证输出结果一致，请将集合内元素排序之后再输出。
输入样例：
abc
bcd
输出样例：
[‘a’, ‘b’, ‘c’, ‘d’]
aset = input()
bset = input()
alist = list(aset)
blist = list(bset)
print(sorted(set(alist+blist)))
- 与7相关的数：如果一个正整数，它能被7整除或者它的十进制表示法中某个位数上的数字为7，则称之为与7相关的数。
现在我们给定一个正整数n（n<1000），求所有小于等于n的与7无关的正整数的平方和。
max = int(input())
sum = 0
for num in range(1,max+1):
if num%7 != 0 and ('7' not in list(str(num))):
sum += num**2
print(sum)
- 输入一个正整数n（n<1000），输出1到n之间的所有完数（包括n）。完数：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如 6 = 1＋2＋3。
num = int(input())
result = []
for i in range(1,num+1):
lis = []
for x in range(1,i):
if i%x == 0:
lis.append(x)
if sum(lis) == i:
print(i)
- 打印一个n层（1
max = int(input())
n = 1
while n <= max:
space = max - n
print(' '*space + '+'*(2*n-1))
n += 1
- 给一个5位数，判断它是不是回文数，是则输出yes，不是则输出no。
例如12321是回文数，它的个位与万位相同，十位与千位相同。
num = int(input())
x = list(str(num))
if x[0] == x[4] and x[1] == x[3]:
print('yes')
else:
print('no')
- 输入一个列表alist，要求列表中的每个元素都为正整数且不超过10；
将列表中的奇数变为它的平方，偶数除以2后打印新的列表（新的列表中所有元素仍都为整数）。同时为保证输出结果一致，请将集合内元素排序之后再输出。
alist=list(map(int,input().split()))
result = []
for i in alist:
if int(i)%2 == 0:
result.append(int(i)//2)
else:
result.append(int(i)**2)
print(sorted(result))
- 给定一个大于2的正整数n，打印出小于n（不包括n且n不大于100）的所有素数。
要求将符合条件的输出填入一个列表中，打印的结果为该列表。
max = int(input())
num = []
i=2
for i in range(2,max):
j=2
for j in range(2,i):
if(i%j==0):
break
else:
num.append(i)
print(num)
- 猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第n天（<1
day = int(input())
all = 1
for i in range(1,day):
all = (all + 1)*2
print(all)
章节六：计算与控制流（二）
- 斐波拉契数列：这个数列从第三项开始，每一项都等于前两项之和。
已知斐波拉契数列的前两项都是1，我们定义求斐波拉契数列的第n项（n<=50）的函数为fbnq，程序主体如下：
n=int(input(""))
print(fbnq(n))
请补充完成对fbnq函数的定义。
n=int(input(""))
def fbnq(x):
if x <= 2:
result = 1
return result
else:
list = [1,1]
i = 1
while i <= n-2:
next = list[-1] + list[-2]
list.append(next)
i += 1
return list[-1]
print(fbnq(n))
- 输入两个正整数num1和num2（不超过1000），求它们的最大公约数并输出。
我们定义求最大公约数的函数为hcf，给出程序主体如下：
num1=int(input(""))
num2=int(input(""))
print(hcf(num1,num2))
请补充完成hcf函数的定义。
num1=int(input(""))
num2=int(input(""))
def hcf(x,y):
list = []
for i in range(min(x,y)):
if x%(i+1) == 0 and y%(i+1) == 0:
list.append(i+1)
else:
pass
return max(list)
print(hcf(num1,num2))
- 输入两个正整数num1和num2（不超过500），求它们的最小公倍数并输出。
我们定义求最小公倍数的函数为lcm，给出程序主体如下：
num1=int(input(""))
num2=int(input(""))
print(lcm(num1,num2))
请补充完成lcm函数的定义。
num1=int(input(""))
num2=int(input(""))
def lcm(x,y):
num = max(x,y)
while num>0:
if num%x == 0 and num%y == 0:
return num
else:
num += 1
print(lcm(num1,num2))
- 我们定义求n（n为正整数且n<=20）的阶乘的函数为fact，给出程序主体如下：
n=int(input(""))
print(fact(n))
请补充完成对fact函数的定义。
n=int(input(""))
def fact(x):
fc = x
result = 1
while fc > 0:
result *= fc
fc -= 1
return result
print(fact(n))
- 冒泡排序
已知输入为一个列表，列表中的元素都为整数，我们定义冒泡排序函数为bubbleSort，将列表中的元素按从小到大进行排序后得到一个新的列表并输出，给出程序主体如下：
alist=list(map(int,input().split()))
print(bubbleSort(alist))
请补充完成对bubbleSort函数的定义。
alist=list(map(int,input().split()))
def bubbleSort(x):
count = 1
while count != 0:
count = 0
for i in range(len(x)-1):
if x[i] <= x[i+1]:
pass
else:
x[i], x[i+1] = x[i+1], x[i]
count += 1
return x
print(bubbleSort(alist))
- 列表元素筛选
已知输入为一个列表，列表中的元素都为整数，我们定义元素筛选函数为foo，功能是检查获取传入列表对象的所有奇数位索引（注意列表的索引是从0开始的）对应的元素，并将其作为新列表返回给调用者。给出程序主体如下：
alist=list(map(int,input().split()))
print(foo(alist))
请补充完成对foo函数的定义。
alist=list(map(int,input().split()))
def foo(x):
result = []
for i in range(len(x)):
if i%2 == 0:
pass
else:
result.append(x[i])
return result
print(foo(alist))
章节七：基本扩展模块
- 给定年月日，如2019/1/8，打印输出这一天是该年的第几天。
import datetime
y, m, d = map(int,input().split('/'))
today = datetime.date(y, m, d)
count = today - datetime.date(y-1, 12, 31)
print(count.days)
- 题目内容
import math, cmath
x = int(input())
a = math.sin(math.radians(15))
b = cmath.exp(x) - 5*x
b1 = math.pow(x, 2) + 1
b2 = math.pow(b1, 0.5)
c = math.log(3*x, math.e)
result = a + b.real/b2 - c
print(round(result, 10))
- 一个特殊的正整数，它加上150后是一个完全平方数，再加上136又是一个完全平方数，求符合条件的最小的一个数。
x = 0
while True:
x += 1
y1 = x + 150
sqrt1 = y1 ** 0.5
y2 = y1 + 136
sqrt2 = y2 ** 0.5
if y1%sqrt1 == 0 and y2%sqrt2 == 0:
print(x)
break
else:
pass
- 打印出n阶的“叉”，这个叉图案由字符‘+’和‘X’构成，n越大，这个图案也就越大
n = int(input())
for i in range(0,2 * n -1):
for m in range(0,2 * n -1):
if m == i or m == 2 * n - 1 - 1 - i:
print('X',end='')
else:
print('+',end='')
print()
- 已知n个人（以编号0，1，2，3…n-1分别表示）围坐在一张圆桌周围。从编号为0的人开始报数1，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
n=int(input())
m=int(input())
lst=list(range(n))
result=[]
for i in range(n):
for j in range(m-1):
lst.append(lst.pop(0))
result.append(lst.pop(0))
print(result)
章节八：高级特性（一）：面向对象
- 设计一个学生类(Student)，其中的数据成员有：字符串类型sname表示录入的学生姓名，整型值mscore代表学生的数学成绩，整型值cscore代表学生的语文成绩，整型值escore代表学生的英语成绩。
然后要求根据录入的学生成绩（各不相同），输出总分最高的学生姓名和各科目成绩。
class Student:
def __init__(self,a1,a2,a3,a4):
self.name = a1
self.math = a2
self.che = a3
self.eng = a4
def firstinfo(self):
stu_list = []
j=0
for i in self.name:
stu_list.append([i, self.math[j], self.che[j], self.eng[j]])
j += 1
total_points = []
for i in stu_list:
total_points.append(sum(i[1:]))
pos = total_points.index(max(total_points))
print(' '.join(list(map(str, stu_list[pos]))))
name = input().split()
math = list(map(int, input().split()))
che = list(map(int, input().split()))
eng = list(map(int, input().split()))
Student(name, math, che, eng).firstinfo()
- 给定一个列表和一个整数目标，其中列表中的元素都为整数，要求返回列表中的两个元素的索引编号（以列表形式打印,为确保结果唯一，小的编号在前），使这两个元素的和为这个特定的目标。
(只对应确定的唯一一组解，并且不能使用同一个元素两次。)
- 给定两个非负整数x和y，如果某一整数等于xi+yj，其中整数i>= 0且j>=0，那么我们认为该整数是一个"精致"的数。返回值小于或等于n(n<=200)的所有精致的数组成的列表。
结果列表中每个值最多出现一次，同时请使用sorted保证结果唯一。
from math import log
class DeliNum:
def __init__(self,x,y,n):
self.x = x
self.y = y
self.n = n
def delinum(self):
# 根据 x^i+y^j <= n(整数i>=0且j>=0)，求出i,j的可能的最大值
# i的最大值：以x为底的n的对数；j同理
if self.x > 1:
i_max = int(log(self.n, self.x))
else:
i_max = 1
if self.y > 1:
j_max = int(log(self.n, self.y))
else:
j_max = 1
# 创建所有可能的精致的数的列表
deli_list = []
for i in range(i_max + 1):
for j in range(j_max + 1):
num = self.x ** i + self.y ** j
if num <= self.n:
deli_list.append(num)
# 不重复且排序的num_list
result = sorted(list(set(deli_list)))
print(result)
x = int(input())
y = int(input())
n = int(input())
DeliNum(x,y,n).delinum()
- 给定一个列表alist，alist由一些正整数（代表长度）组成，返回由alist中的三个长度组成的有效三角形的最大周长。如果所有的长度组合都不能构成有效三角形，则返回 0。
class MaxRound:
def __init__(self,lst):
self.lst = lst
def maxround(self):
for i in range(len(self.lst)-2):
if self.lst[i] < self.lst[i+1] + self.lst[i+2]:
print(self.lst[i] + self.lst[i+1] + self.lst[i+2])
break
else:
print(0)
a=list(map(int,input().split()))
a.sort(reverse=True)
MaxRound(a).maxround()