Python小屋笔记——编程自测1-50_python小屋编程题答案

1. 计算并返回任意正整数n的阶乘，也就是从1到n所有正整数的乘积。

（或参考10.）

def main(n):
    s = 1
    for i in range(2,n+1):
        s = s*i
    return s

2. 计算并返回任意多个整数的和。

法一：使用while循环

def main(*p):
    n = len(p)
    sum = 0
    while n > 0:
        n -=1
        sum += p[n]
    return sum

法二：

def main(*p):
    return sum(p)
 
# 函数语法：
# sum(iterable[, start])
# iterable – 可迭代对象，如：列表(list)、元组(tuple)、集合(set)、字典(dictionary)。
# start – 指定相加的参数，如果没有设置这个值，默认为0。

3. 给定任意列表lst和一个任意值item，返回item在lst中第一次出现的位置，如果列表lst中不存在元素item则返回字符串’不存在‘。

def main(lst,item):
    if item in lst:
        return lst.index(item) #index返回第一次出现的下标
    else:
        return '不存在'

4. 函数main( )接受一个包含若干整数的列表lst，要求返回一个列表，列表中包含原列表中大于或等于所有整数平均值的整数。

写法一：

def main(lst):
    l=[]
    ave = sum(lst)/len(lst)
    for i in lst:
        if i >= ave:
            l.append(i)
    return 1

写法二：

def main(lst):
    avg = sum(lst) / len(lst)
    return [x for x in lst if x >= avg]

5. 函数main( )接收两个正整数p和q，要求返回一个元组，元组中第一个元素为p整除q的商，第二个元素为p对a的余数。

def main(p,q):
    return divmod(p,q)
 
# divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
 
# 函数语法：
# divmod(a, b)
 
# 参数说明：
# a: 数字，非复数。
# b: 数字非复数。
# 如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。
# 如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)
# q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。

6. 函数main( )接收一个正整数num，要求返回正整数num各位数字之和。

不能使用循环结构和任何形式的推导式，不能使用内置函数eval( )。

def main(num)
   return sum(list(map(int,str(num))))

若使用循环，此处使用while循环：

def main(num):
    retV = num % 10
    while num // 10 > 0:
        num = num // 10
        retV += num % 10
    return retV

7. 函数main( )接收一个包含若干整数的列表lst，要求返回一个新列表，新列表包含原列表lst中的唯一元素（重复的元素只保留一个）并且所有元素保持在原列表中首次出现的相对顺序。例如，调用函数main([1 , 2 , 3 , 1 , 4]) 会输出 [1 , 2 , 3 , 4]。不能使用循环结构和任何形式的推导式。

法一：

def main(lst):
    return list(dict.fromkeys(lst))
 
# fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
# 方法语法：
# dict.fromkeys(seq[, value])
# seq -- 字典键值列表。
# value -- 可选参数, 设置键序列（seq）的值，默认为 None。

法二：

def main(lst):
    temp = lst(set(lst))
    return sorted(temp,key=lambda x:lst.index(x))
 
# 函数语法：
 
# sorted(iterable, cmp=None, key=None, reverse=False)
 
# 参数说明：
# iterable -- 可迭代对象。
 
# cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出。
# 此函数大于则返回1，小于则返回-1，等于则返回0。【必须遵守的规则】
 
# key -- 主要是用来进行比较的元素，只有一个参数。
# 具体函参取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
 
# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
 
# 返回重新排序的列表。

8. 函数main( )接收包含若干字符串的列表lst，要求返回一个新列表，新列表中包含原列表lst中每个字符串变成小写之后的字符串。

法一：

def main(lst):
    return list(map(str.lower,str))

法二：

def main(lst):
    return [x.lower() for x in lst]
 
# lower()：将字符串中的所有大写字母转换为小写字母。
 
# 函数语法：
# str.lower()
 
# upper() 的功能和 lower() 方法恰好相反，它用于将字符串中的所有小写字母转换为大写字母，和以上两种方法的返回方式相同，即如果转换成功，则返回新字符串；反之，则返回原字符串。
# 函数语法：
# str.upper()
 
# -> str 返回字符串

9. 函数main( )接收一个包含若干字符串的列表lst，要求把这些字符串按长度从大到小排序并返回包含排序之后字符串的新列表。

def mian(lst):
    return sorted(lst,key = lambda x:len(x),reverse = True)
 
# 函数：
# sorted() - 这是一个内置函数，用于对可迭代对象进行排序。它返回一个新的已排序的列表，不改变原始列表。
# 参数：
# lst - 这是被排序的可迭代对象（通常是一个列表），根据指定的规则对其元素进行排序。
# key = lambda x:len(x) - 这是一个可选参数，用于指定排序的比较规则。在这种情况下，使用了一个lambda函数，该函数根据元素的长度来进行排序。lambda函数接受一个参数 x，并返回 x 的长度，即字符串或列表的元素个数。
# reverse = True - 这也是一个可选参数，用于指定排序的顺序。如果将其设置为 True，则按降序排序；如果设置为 False，则按升序排序。在这种情况下，由于设置为 True，因此元素将按长度降序排列。

lambda完整详解和巧妙运用可以看这篇文章：
https://blog.csdn.net/PY0312/article/details/88956795

10. 函数main( )接收一个正整数n，返回n的阶乘n!=1*2*3*...*n，要求编写代码调用该函数：分别计算并输出20的阶乘、30的阶乘和40的阶乘。

# 使用reduce和operator.mul函数计算阶乘
from functools import reduce
from operator import mul
 
def main(n):
    return reduce(mul, range(1，n+1))
 
print(main(20))
print(main(30))
print(main(40))
 
# mul 是乘法指令，使用 mul 做乘法的时候：相乘的两个数：要么都是8位，要么都是16位。 
# 8 位： AL中和 8位寄存器或内存字节单元中；
# 16 位： AX中和 16 位寄存器或内存字单元中。 结果 8位：AX中； 16位：DX（高位）和 AX（低位）中。

11. 已知标准库operator中的mul函数相当于乘号运算符可以用来计算两个数字的乘积，函数main)接收两个包含若干整数的列表vector1和vector2，并且vector1和vector2的长度相等，分别表示两个向量，要求计算并返回两个列表表示的向量的内积，也就是对应分量乘积的和。例如，对于参数vector1 [1，2，3]和vector2[4，5，6]计算1*4 +2*5+3*632返回32。

# 数学意义：计算两个向量（vector1和vector2）的内积（点乘），即对应位置上的元素相乘并求和。
from operator import mul
 
def main(vector1,vector2):
    return sum(list(map(lambda x,y: x*y, vector1, vector2)))
 
# from operator import mul: 该行导入了operator模块中的mul函数，用于执行两个数相乘的操作。
# return sum(list(map(lambda x,y: x*y, vector1, vector2)))：
# 在main函数中，首先应用了map函数来将vector1和vector2对应位置上的元素进行相乘操作
# （通过lambda函数定义了一个匿名函数来实现乘法操作）之后，将结果转化为列表，
# 并使用sum函数计算列表中所有元素的和，最终返回该和作为函数的结果。

12. 函数main( )接收一个包含若干字符串的列表lst，要求返回最长的一个字符串。

def main(lst):
    return max(lst,key = len)

13. 函数main( )接收一个包含若于整数的列表lst，要求返回一个包含原列表1st中所有非0整数的新列表，并且其中的所有整数保持原来的相对顺序。例如，接收列表[1,2,0,3,0,4]，返回新列表[1,2,3 4]。

def main(lst):    
    return list(filter(lambda x:x!=0,lst))

* 知识补充：对比filter( )和map( )方法

numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出 [2, 4]

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # 输出 [1, 4, 9, 16, 25]

14. 函数main( )接收一个包含若干整数的列表lst，要求返回其中绝对值最大的整数。

def main(lst):
    return max(lst,key = abs)

15. 函数接收一个包含若干整数的列表lst，要求返回其中所有奇数组成的新列表，且所有元素
保持原来的相对顺序。

def main(lst):
    return [x for x in lst if x % 2 != 0]

16. 函数main( )接收一个字符串s，要求返回一个长度为20的新字符串，原字符串s的内容在新字符串中居中，如果原字符串s长度小于20，就在新字符串两侧使用井号#填充，如果原字符串s的长度不小于20，则不进行填充并返回原字符串。

def main(s):
    return s.center(20,'#') if len(s) < 20 else s
 
# center() 方法是字符串类型的一个内置方法，用于将字符串居中放置于指定宽度的字符串中，并用指定字符进行填充。
 
# 语法：
# string.center(width, fillchar)
 
# 参数：
# width：表示最终字符串的宽度，即居中后的字符串所占用的字符数。
# fillchar（可选）：表示填充字符，用于在字符串两侧填充以达到指定宽度。如果未提供fillchar参数，默认# 使用空格字符进行填充。
 
# 返回值：
# center() 方法返回一个新的字符串，其中原始字符串被居中放置在指定宽度内，并根据需要用指定字符进行填充。

17.  函数main( )接收一个字符串s，要求把其中的阿拉伯数字0、1、2、3、4、5、6、7、8、9分别变为零、三、四、五、六、七、八、九，其他非阿拉伯数字保持不变，返回处理后的新字符串，注意要使用单引号。

 
# 使用translate()方法来进行字符串转换
 
def main(s):
    inStr = '0123456789'
    outStr = '零一二三四五六七八九'
    return s.translate(s,maketrans(inStr,outStr))
 
# translate() 方法是字符串类型的一个内置方法，在字符串中执行字符级别的转换或删除操作。
 
# 语法：
# string.translate(table)
 
# 参数：
# table：表示转换表，可以通过使用 maketrans() 函数创建。转换表指定了从一个字符到另一个字符的映射关系。也可以传入一个删除表，用于指定要从字符串中删除的字符。
 
# 返回值：
# translate() 方法返回一个新的字符串，其中根据转换表进行字符级别的转换或删除操作后的结果。
 
# s是要进行转换的字符串，maketrans(inStr, outStr)创建了一个转换表
# 该表指定了从inStr中的字符到outStr中对应位置字符的映射关系
# 返回值是转换后的字符串

18. 函数main( )接收一个包含若于整数的列表lst，要求判断列表中是否存在重复的整数。如果列表中所有整数完全一样则返回整数0，如果列表中的所有整数互不相同则返回整数1，如果列表中有部分整数相同则返回整数2。

def main(lst):
    s = set(lst)
    if len(s) == 1 and len(lst) != 1:
        return 0
    elif len(s) == len(lst):
        return 1:
    else:
        return 2

19.函数main( )接收一个任意字符串s，要求删除英文字母之外的其他所有字符，然后判断剩余的英文字母字符串是否为回文，是回文则返回True，否则返回False。例如，接收字符串'0abicde234d98cba'，删除英文字母之外的字符后得到字符串 'abcdedcba'，是回文，返回True。

# 使用re模块来处理正则表达式
import re
 
def main(s):
    ns = re.sub(r'[^a-zA-Z]','',s)
    if ns[::-1] == ns:
        return True
    else:
    return False
 
# re.sub() 函数接受三个参数：
# 正则表达式模式 r'[^a-zA-Z]'、替换字符串 ''（空字符串）、和输入字符串 s。
# 该正则表达式模式 [^\w] 表示匹配任何非字母字符，包括标点符号、数字和空格等。
# 使用空字符串进行替换，相当于将非字母字符从输入字符串 s 中删除，并将结果赋给变量 ns。
 
# 使用切片（slice）操作符 [::-1] 对字符串 ns 进行反向切片，将字符串反转
# 回文：从前往后和从后往前读取都相同

20. 函数main( )接收一个任意字符串s，要求返回其中出现次数最多的前3个字符组成的列表并按出现次数从多到少排列。例如 接收字符串 abbccdddeeee，返回['e'，'d'，'b']。

法一：

# collections 模块中的 Counter 类，用于计数可迭代对象中元素的出现次数
 
from collections import Counter
 
def main(s):
    return list(map(lambda x:x[0],Counter(list(s)).most_common(3)))
 
# list(s) 将字符串 s 转换为一个字符列表
# Counter(list(s)) 创建一个计数器对象，统计字符列表中每个字符的出现次数
# most_common(3) 使用计数器对象的 most_common() 方法获取出现次数最多的前三个元素
# 返回的结果是一个包含元素及其出现次数的元组的列表，按照出现次数的降序排列
 
# map(lambda x:x[0], ...) 遍历这个元组列表，并提取出每个元组的第一个元素，即字符
# 这个 lambda 函数接收一个元组参数 x，返回元组的第一个元素

法二：

使用列表推导式

from collections import Counter
 
def main(s):
    lst_dict = Counter(s).most_common(3)
    return [lst_dict[0][0],lst_dict[1][0],lst_dict[2][0]]
 
# 使用列表推导式，从 lst_dict 中提取出前三个元素，并把它们的第一个元素（也就是字符）组成一个新的列表，然后将这个列表作为返回值
 
# most_common(3) 返回的结果是一个包含元素及其出现次数的元组的列表，按照出现次数的降序排列
# 因此通过索引 [0] 可以获取到第一个元素，即字符
# 这个函数的作用是获取输入字符串 s 中出现频率最高的前三个字符，并将它们存储在一个列表中返回
 
# 要注意这种方式取决于字符串中字符的频率，如果有多个字符具有相同频率，则选择任意三个进行返回

21. 函数isPrime( )接收一个大于等于2的正整数num，判断其是否为素数，素数时返回True，否则返回False。
函数main( )接收一个大于等于2的正整数n，要求返回不超过n的最大素数，可以调用程序中定义的函数isPrime( )。例如，n=200时返回199，n=100时返回97，n=2时返回2。

def isPrime(num):
    if num == 2:
        return True
    for i in range(2,int(num**0.5)+1):
        if num % i == 0:
            return False 
    return True
 
# isPrime 函数用于判断一个数是否为素数。
# 首先，如果输入的数 num 为2，则直接返回True，因为2是最小的素数。
# 接下来，使用循环从2到平方根的整数部分加1（int(num**0.5) + 1）进行遍历，将当前循环变量记作 i。
# 在每次循环中，检查 num 是否可以被 i 整除。如果可以被整除，说明 num 不是素数，返回 False。
# 如果在循环结束时都没有找到能够整除 num 的数，则说明 num 是素数，返回 True。
 
def main(num):
    for i in range(num,1,-1):
        if isPrime(i):
            return i
 
# main 函数从输入的数 num 开始倒序遍历，也就是从 num 到 1 进行遍历，步长为 -1。
# 对每个遍历到的数 i，通过调用 isPrime(i) 调用 isPrime 函数来判断该数是否为素数。
# 如果某个数 i 是素数，则通过 return i 返回该素数，并结束函数执行。
# 这表示 main 函数的，main 函数的返回值是输入数 num 及其之前的最大素数。
# 作用是获取输入数 num 及其之前（包括自身）的最大素数，并将其返回。

22. 函数main( )接收两个正整数n和i，返回组合数C（n，i）的值，也就是从n个物体中任选i个物体有多少种选法。

法一：

通过迭代计算给定的组合数，遵循组合数的定义原理：从 n 个物体中选取 i 个物体的种类数。

def main(n, i):
    if i > n or i < 0:
        return 0
    result = 1
    for x in range(i):
        result *= (n - x)
        result //= (x + 1)
    return result
 
# 函数的逻辑如下所示：
 
# 首先，对于 i > n 或者 i < 0 的情况，没有合法的选择方式，因此直接返回 0
 
# 创建一个变量 result 并初始化为 1。使用循环从 0 到 i-1 进行迭代，并针对每个循环变量 x 更新结果
# 在每次迭代中，将 result 乘以 (n - x)，表示当前可选的物体数量减少
# 使用整数除法操作 // 将 result 除以 (x + 1)，即当前正在选取的物体数量加一，以确保结果为整数
# 最后返回计算得到的 result，即为组合数 C(n, i) 的值。

法二： 

我们可以观察到，分子和分母中的都是连续的整数乘积。由于连乘的运算符具有结合律，我们可以将连乘看作一个累积操作，对范围内的每个元素都进行一系列运算。

reduce 函数用于对可迭代对象进行递归累积操作，并返回一个单一的值。

完整形式是 functools.reduce(function, iterable[, initializer])。

接受两个必要参数：

• function：一个二元函数，该函数定义了如何对两个元素进行操作。
• iterable：一个可迭代对象，例如列表、元组、集合等。

reduce 函数对 iterable 中的第一个和第二个元素调用 function，然后再将结果与下一个元素调用 function，依此类推，直到迭代完所有元素并返回最终的结果。

# 使用 functools 模块中的 reduce 函数来计算组合数 C(n, i)。
from functools import reduce
 
def main(n,i):
    return int(reduce(lambda x, y : x * y, range(n - i + 1, n + 1)) / reduce(lambda x, y: x * y, range(1, i + 1)))        
 
# 函数的逻辑如下所示：
 
# 第一个 reduce 函数用于计算 (n - i + 1) * (n - i + 2) * ... * n
# 即从 n - i + 1 到 n 的连乘积
# 它使用了一个匿名函数 lambda x, y: x * y 作为累加函数，将范围内的元素依次相乘
 
# 同样地，第二个 reduce 函数用于计算 1 * 2 * ... * i，即从 1 到 i 的连乘积。
 
# 最终，将两个结果相除，并使用 int() 函数将结果转换为整数类型，以获得最终的组合数值。
 
# 此方法虽然简洁，但可能不易于阅读和理解。

本题中传入reduce函数的第一个参数是一个二元函数，该函数定义了如何对两个元素进行操作。 

而第二个参数则是一个可迭代对象，在例子中是使用range函数来生成需要运算的连续整数序列。

23. 函数main( )接收一个大于等于1的正整数n和一个介于[0, 9]区间的正整数a，要求返回表达
a+aa+aaa+aaaa+...+aa..aa前n项的和。例如，当n=3和a=1时，计算1+11+111，返回123。

法一：

def nain(n,a):
    nums = range(1,n+1)
    s = sum(map(lambda x: int(str(a)*x), nums))
    return s
 
# 函数的逻辑如下所示：
 
# 首先，使用 range(1, n+1) 创建从 1 到 n 的整数序列，并存储在 nums 变量中
# 然后，通过 map 函数对 nums 序列中的每个元素进行操作
# 该操作是基于输入的数字 a，将其转换为字符串并重复相应的次数
# 这样就生成了一个新的可迭代对象，包含了重复数字的序列
# 将这个序列传递给 sum 函数，计算所有元素的总和，并将结果存储在变量 s 中
# 最后返回总和 s
# 这段代码实现了一个功能，即对从 1 到 n 的数字中的每个数字，都重复以 a 字符串作为单位的倍数次数，并计算这些数字的总和
 
# 需要注意，在代码中将字符串类型（a）与数字类型（x）进行运算时，会自动将数字转换为字符串来进行处理

法二：

def main(n, a):
    term = str(a)  # 将数字a转换为字符串形式
    series = [int(term * i) for i in range(1, n+1)]  # 生成前n项的列表
    total_sum = sum(series)  # 计算列表中所有元素的和
    return total_sum
 
# 函数的逻辑如下所示：
 
# 首先，将输入的数字 a 转换为字符串形式，存储在变量 term 中。
# 然后，使用列表推导式生成一个包含前n项的列表 series。
# 通过对于每个i在 range(1, n+1) 上迭代，使用 term * i 创建相应项，并将其转换为整数类型。
# 使用 sum() 函数对列表 series 中的所有元素进行求和，将结果存储在变量 total_sum 中。
# 最后返回求和结果 total_sum。

24. 已知当前文件夹中文件data24.txt中有若干使用英文半角号分隔的整数，函数main( )用来读取文件data24.txt中的内容，把每个数字乘以10，返回这些乘积结果组成的列表。

例如，如果文件data24txt中的内容为23,34，函数main( )会返回[230, 340]

简化题目：读取data24.txt的内容，把每隔数字乘以10，返回这些乘积结果组成的列表

def main():
    with open('data24.txt','r') as f:
        lines = f.readlines()
 
# 使用内置函数open()来打开文件
# 使用 with 关键字打开文件 "data24.txt" 并将其赋值给变量 f
# 在 with 块内，通过调用 f.readlines() 方法，按行读取文件的内容，并将每一行作为字符串存储在列表 lines 中
 
    products = []
    for line in lines:
        nums = [int(x)*10 for x in line.strip().split(',')]
        products.extend(nums)
 
    return products
 
# 创建一个空列表 products，用于存储处理后的数据
# 对于 lines 列表中的每一行，使用 line.strip().split(',') 对字符串进行处理
# ：去除首尾的空白字符，然后按逗号拆分成多个子字符串
# 注意：split()拆分字符串时，先用strip()方法删除首尾空格
 
# 对每个子字符串转换为整数类型，并将其乘以 10
# 将处理后的结果存储在名为 nums 的临时列表中
# 使用 extend 方法将 nums 列表中的所有元素添加到 products 列表中
 
 
if __name__ == '__main__':
    print(main())

 * 知识补充：对比 append( )方法和extend( )方法

Ⅱ extend 方法：用于将一个可迭代对象的有元素添加到列表的末尾。

语法如下：

# 使用 append 方法
 
fruits = ['apple', 'banana']
fruits.append('orange')
print(fruits)  # 输出: ['apple', 'banana', 'orange']
 
 
# 使用 extend 方法
 
numbers = [1, 2, 3]
numbers.extend([4, 5, 6])
print(numbers)  # 输出: [1, 2, 3, 4, 5, 6]

25. 函数main( )接收一个包含若干集合的列表lst，要求返回这些集合的并集。

def main(lst):
    s = set(lst[0])
    for i in range(1, len(lst)):
        s = set.union(s, set(lst[i]))
    return s
 
# 函数的逻辑如下所示：
 
# 首先，初始化一个集合 s，并将参数列表 lst 的第一个元素转换为集合。
# 然后，通过在循环中遍历列表的其余元素，将每个元素也转换为集合，并使用 set.union() 方法进行集合的合并。将合并结果赋值给变量 s。
# 最后，返回合并后的集合 s。
 
# 该代码的目标是将传入的列表 lst 中的所有元素合并成一个集合，并返回该集合。这样可以消除重复元素，保留列表中的唯一值。
 
## 请注意，该实现使用了 set.union() 方法来合并集合，确保最终结果不包含重复的元素。

* 知识补充： set.union( )方法

set1 = {1, 2, 3}
set2 = {3, 4, 5}
result_set = set.union(set1, set2)
print(result_set)  # 输出: {1, 2, 3, 4, 5}

26. 函数main( )接收一个包含若于表示角度的实数的列表lst，要求返回这些实数转换为弧度之后的正弦值组成的新列表。

（简化版）：

使用列表推导式

import math
 
def main(lst):
    sin_lst = [math.sin(math.radians(angle)) for angle in lst]
    return sin_lst

1. math.sin(x)：这是 math 模块中的一个函数，用于计算给定角度（以弧度为单位）的正弦值。在这段代码中，使用 math.sin() 来计算每个角度值的正弦值。

2. math.radians(x)：这是 math 模块中的一个函数，用于将给定角度转换为弧度。在这段代码中，使用 math.radians() 将角度值转换为弧度，以便计算其正弦值。

3. 列表推导式 [math.sin(math.radians(angle)) for angle in lst]：这是一种简化列表创建过程的语法。它遍历输入列表 lst 中的每个元素 angle，并将每个角度值转换为弧度、计算其正弦值，并将结果存储在新列表 sin_lst 中。

27. 函数main( )接收6个整数，其中year1、month1、day1表示一个日期的年、月、日，year2、month2、day2表示另一个日期的年、月、日，要求返回这两个日期之间相差的天数（必须为正数或0）

from datetime import date
 
def main(year1,month1,day1,year2,month2,day2):
    return abs((date(year1,month1,day1)-date(year2,month2,day2)).days)

28. 函数main( )接收一个表示年份的正整数year，要求判断是否为闰年，是闰年就返回字符串'yes'，否则返回字符串'no'。

def main(year):
    if (year %4 == 0 and year% 100 != 0) or year % 400 == 0:
        return 'yes'
    else:
    return 'no'

29. 函数main( )接收一个单参数函数func和一个包含若千实数的列表lst，要求计算lst中的每个实数作为自变量func的函数值，返回其中的最大值。

def main(func,lst):
    return max([func(x) for x in lst])

30. 函数main()接收一个包含若干正整数的元组tup，要求计算并返回这些整数的截尾平均数也就是去掉一个最高分再去掉一个最低分之后剩余数字的算术平均数，结果保留1位小数。

def main(tup):
    tup = sorted(tup)
    n = len(tup)
    return round(sum(tup[1:n-1])/(n-2),1) if n > 2 else round(sum(tup)/n,1)
 
# 如果n大于2，表示元组中至少有三个元素
# 使用切片从索引1到n-1（不包括第一个和最后一个元素）取子元组tup[1:n-1]
# 使用sum()函数计算子元组中元素的总和
# 将计算得到的总和除以n-2以获得平均值，并使用round()函数将其四舍五入到小数点后一位
# 返回四舍五入的平均值作为函数的结果
 
# 如果n小于或等于2，表示元组中有一个或两个元素：
# 使用sum()函数计算元组中所有元素的总和
# 将总和除以n以获得平均值，并使用round()函数将其四舍五入到小数点后一位
# 返回四舍五入的平均值作为函数的结果

* 知识补充： sorted( )函数

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法如下：

        sorted(iterable, cmp=None, key=None, reverse=False)

参数说明：

• iterable -- 可迭代对象。
• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

31. 函数main( )接收一个正整数n，要求返回斐波那契数列中前n项的和。

法一：

def main(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    lst = [1,1]
    for i in range(2,n):
        lst.append(lst[i-1] + lst[i-2])
    return sum(lst)

 法二：

def main(n):
    if n <= 2:
        return n
    a, b = 1, 1
    total_sum = 2
    for _ in range(3, n+1):
        a, b = b, a + b
        total_sum += b
    return total_sum
 
# 函数首先检查边界情况，如果n小于或等于2，则直接返回n
# 创建两个变量a和b来追踪斐波那契数列的当前项和下一项
# 创建变量total_sum来存储前n项的和，并初始化为2，因为已知前两项的和为2
# 在循环中，从第三项开始，通过将a和b更新为下一个斐波那契数列的值，并将该值加到total_sum中
# 最后返回total_sum作为前n项的和

32. 函数main( )接收一个字符串s和一个正整数n，要求返回字符串s重复n次之后的长字符串，如果只传递字符串s就返回重复3次得到的字符串，也就是n默认为3。例如，传递参数'abc'和2返回'abcabc'，传递参数'ab'返回'ababab'。

def main(s,n=3):
    return s*n

33. 函数main( )接收一个字符串s和一个正整数n，其中的大小不超过s的长度，要求返回字符串s循环左移n位之后的结果。例如，接收字符串'abcdefg'和3，返回'defgabc'。

def main(s,n):
    return s[n:] + s[0:n]

34. 类Number用来模拟整数类型的部分操作，要求构造方法可以接收一个整数，并且支持两个Number对象的加法运算，返回一个Nmber对象，使用print( )内置函数输出Number对家时得到Number对象内部实际的值。main( )函数接收两个Number对象，返回一个Number对象。例如传递参数Number(3)和Number(5)时函数man( )返回一个Number对象，使用print( )输出该对象时得到8。

class Number:
    def __init__(self, value):
        self.value = value
    def __add__(self, another):
        return Number(self.value + another.value)
    def __str__(self):
        return str(self.value)
 
def main(x,y):
    return x+y

35. 类Number模拟一个整数或实数类的部分操作，要求支持接收一个整数或实数然后创建一个Number对象（如果初始值不是整数或实数，则设置内部数据成员的值为整数0），为Number实现属性value并支持返回和修改Number对象内部数据成员的值，要求内部数据成员只能为整数或实数，如果试图修改内部数据成员的值为非整数或实数时，保持原来的值不变。

函数main( )接收两个整数或实数x、y作为参数，首先创建一个Number对象obj并设置内部数据成员的值为x，然后修改Number对象obi的内部数据成员值为y，最后返回obj的类型以及obj的属性value的值。

class Number :
    def __init__(self, value):
        if type(value) != int and type(value) != float:
            self. value = 0
        else:
            self. value = value
    def __set(self, value):
    if type(value) == int or type(value) == float:
        self.value = value
    def __get(self):
        return self.value
    value = property(__get,__set)
 
def main(x,y):
    obj = Number(x)
    obj.value = y
    return (type(obj),obj.value)

36. 函数main( )接收任意多个表示电阻值的正整数，要求计算并返回这些电阻并联时的实际电阻值，结果保留1位小数。已知多个电阻并联时，实际电阻的倒数为每个电阻值的倒数之和。

def main(*para):
    return '[:.1f)'.format(1 / sum([1 / x for x in para]))

37. 函数接收一个正整数n，要求判断其是否为黑洞数，如果是则返回True，否则返回False。如果一个整数n的各位数字能够组成的最大数减去能够组成的最小数的差恰好等于原来的数字n，那么n就是黑洞数。例如，495是黑洞数，因为各位数字能够组成的最大数954与能够组成的最小数459的差为495。

def main(n):
    lst = list(str(n))
    lst.sort()
    iMin = int(''.join(lst))
    lst.reverse()
    iMax = int(''.join(lst))
    if iMax - iMin == n:
        return True
    else:
        return False

38. 函数main( )接收一个正整数n；要求判断其是否为水仙花数，如果是就返回True，否则返回False。如果一个k位正整数n的各位数字的k次方之和恰好等于原来的数字n，那么n为水仙花数。

def main(n):
    lst = list(str(n))
    k = len(lst)
    nlst = [pow(int(x),k) for x in lst]
    if sum(nlst) == n:
        return True
    else:
        return False

39. 函数main( )接收一个包含若干整数的列表1st，要求返回其中所有数字绝对值之和。例如，lst为[-3,1,2]时返回6。
 

def main(lst):
    return sum([abs(x) for x in lst])

40. 函数main( )接收一个字符串s，要求返回一个元组，元组中第一个元素是s使用UTF8编码之后的字节串，元组中第二个元素是s使用GBK编码之后的字节串。如果参数s不是字符串，返回'参数必须为字符串'。

def main(s):
    try:
        return(s.encode('UTF-8',s.encode('GBK'))
    except:
        return'参数必须为字符串'

41. 函数main( )接收若干字符串，如果第一个字符串包含从第二个往后的所有字符串，函数返回True，否则返回False。 例如，调用main('abcd','a','b','c')返回True。

def main(s1,s2,*s3):
    if s2 in s1:
        for s in s3:
            if s not in s1:
                return False
        return True
    else:
        return False

42. 函数main( )接收一个参数r，要求计算并返回以r为半径的圆的面积，使用math模块中已经导入的圆周率PI，结果保留2位小数。如果参数r不是大于0的整数或实数，就返回字符串'参数必须是大于0的整数或实数'，注意要使用单引号。

from math import pi as PI
 
def main(r):
    if isinstance(r(int,float)) anf r > 0:
        area = PI * r ** 2
        return round(area,2)
    else:
        return '参数必须是大于0的整数或实数'

43. 函数main( )接收一个包含若干正整数的列表lst，要求返回这些正整数首尾相接能够组成的最大数字。例如，lst为[12，34，4]时，返回43412。

from itertools import permutations
    
def main(lst):
    a =[]
    for j in permutations(lst):
        a.append(''.join('%d'%o for o in j)
    return max(a)

44. 假设某棋盘共有n行n列小格子，在第一个小格子里放1粒米，第二个小格子里放2粒米，第三个小格子里放4粒米，第四个小格子里放8粒米，以此类推，后面每个小格子里米是前个小格子的2倍。函数main( )接收正整数n，计算n行n列棋盘所有小格子里米粒的总数。

def main(n):
    return 2 ** (n*n)-1

45. 函数main( )接收包含若干字符串的列表lst，返回其中变成小写之后最大的字符串。如果参数1st不是列表或者其中的元素不都是字符串，返回字符串'数据格式不正确'。例如，Ist为['a', 'b', 'E']时函数返回'E'，lst为3或者[3, 'a']时函数返回字符串'数据格式不正确'，注意要使用单引号。

（简化版）写法一：

def main(lst):
    if isinstance(lst, list) and all(isinstance(x, str) for x in lst):
        return max(lst, key=lambda x: x.lower())
    else:
        return '数据格式不正确'
 
# sinstance()检查参数lst是否是列表类型，以及所有元素是否都是字符串类型
# 如果不满足这两个条件，则立即返回字符串'数据格式不正确'
# 使用max()函数找到列表中的最大字符串
# 通过key = lambda x: x.lower()指定按小写形式比较字符串

写法二：

def main(lst):
    if isinstance(lst,list) and len(list(filter(lambda x:isinstance(x,str)lst))) == len(lst):
        return sorted(lst,key = str.lower)[-1]
    else:
        return '数据格式不正确'

46. 函数main( )接收一个包含若干整数或实数的列表lst，要求返回其中出现次数最多的一个，如果有多于一个并列最多，就返回最大的一个。例如，lst为[1, 1, 1, 2, 3, 4, 4, 4]时返回4，lst为[1, 1, 1, 2, 3, 4]时返回1。

from collections import Counter
 
def main(lst):
    lst = Counter(lst).most_common()
    return sorted(filter(lambda x: x[1] == lst[0][1],lst),key = lambda x:x[0],reverse=True)[0][0]

1. from collections import Counter: 导入Counter类，用于计算列表中各元素的频次。
2. lst = Counter(lst).most_common(): 使用Counter类计算列表lst中各元素的频次，并将结果存储在lst变量中。这里的most_common()方法返回一个由元素和其对应频次构成的元组列表。
3. filter(lambda x: x[1] == lst[0][1], lst): 使用filter()函数筛选出频次与最高频次相等的元素。lambda x: x[1] == lst[0][1]表示匿名函数，用于检查元组的第二个元素（频次）是否与最高频次相等。
4. sorted(..., key=lambda x: x[0], reverse=True): 使用sorted()函数对筛选后的元素进行排序，基于元组的第一个元素（字符串本身），以字典序降序排列。
5. [0][0]: 取排序结果中的第一个元组的第一个元素，即频次最高且字典序最大的字符串。

47. 函数main( )接收表示三角形两个边长的实数a、b以及表示它们来角的实数theta(单位为角度），要求根据余弦定理计算并返回第三边长，保留1位小数。要求a、b都是大于0的实数，theta是介于(0,180)开区间的实数，否则返回'数据不对'。例如a=3、b=4、theta=90时返回5.0，a=-3、b=4、theta=90时返回'数据不对'，注意要使用单引号。

def main(a, b, theta):
    if isinstance(a, (int, float)) and isinstance(b, (int, float)) and isinstance(theta, (int,float)):
        if a <= 0 or b <= 0 or theta <= 0 or theta >= 180:
            return '数据不对'
        else:
            return round(sqrt(a ** 2 + b ** 2 - 2 * a * b * cos(radians(theta))), 1)
    else:
        return '数据不对'

48. 函数main( )接收两个包含若干整数的列表vector1和vector2，要求查两个参数是否为列表、是否长度相等且只包含整数或实数，如果是则计算并返回对应位置元素之差绝对值的和，否则返回字符串'数据不对'。例如，对于参数vector1 =[1, 2, 3]和vector2[4, 5, 6]，计算abs(1-4)+abs(2-5)+abs(3-6)=9。

def main(vector1,vector2):
    if isinstance(vector1, list) and isinstance(vector2, list):
        l1 = list(filter(lambda x:isinstance(x, (int, float)), vector1))
        l2 = list(filter(lambda x:isinstance(x, (int, float)), vector2))
        if len(vector1) == len(l1) and en(vector2) == len(l2) and len(l1) == len(l2):
            zipped = zip(vector1, vector2)
            return sum(map(lambda x: abs(x[0]-x[1],zip(vector1,vector2))))
        else:
            return '数据不对'
    else:
        return '数据不对'

49. 函数main( )接收一个表示百分制成绩的实数score，要求返回对应的字母等级。'A' 对应于[90,100]，'B' 对应于[80,90)，'C' 对应于[70,80)，D"对应于[60,70)，'F' 对应于[0,60)，其他参数值一律返回字符串'数据不对'，注意要使用单引号。

def main(score):
    if isinstance(scorem,(int,float)) and score >= 0 and score <= 100:
        lst =[(90,'A'),(80,'B'),(70,'C'),(60,'D'),(0,'F')]
        return list(filter(lambda x:score >= x[0],lst))[0][1]
    else:
        return '数据不对'

50. 函数main( )接收一个正整数n，要求返回斐波那契数列中小于等于n的最大数。例如，n=55时返回55，n=400时返回377。

def main(n)
    a, b = 1, 1
    while True:
        a, b = b, b + a
        if b > n:
            return a
        elif b == n:
            return b