Python学习----基础知识及题型

1.有些语句（如if，else，while）的末尾是冒号“ : ”，这样，下面的若干行就要缩进 至少一个 空格。回车自动缩进4个空格。

2.Python3不再区分整数和长整数，统一为 int 类型。

3.符号“#”后面跟的内容是程序里的备注与注释。（大多数理解仅仅是注释）

4.Python语言最适合的应用领域是网站开发与人工智能应用。（Python语言在移动app开发方面尚没有很好的商业化支持，有一些支持库可以用Python语言来学习手机app开发。  ​网页游戏前端开发一般使用Javascript+HTML5+CSS，或者过时的Flash。）

5.归并排序：

#使用二分法归并排序：
def merage_sort(lst):              #创建函数merage_sort，接收列表
    if len(lst) <=1:               
        return  lst
    middle = int(len(lst)/2)
    left = merage_sort(lst[:middle])
    right =merage_sort(lst[middle:])
    listone=[]
    while left and right:
        listone.append(left.pop(0) if left[0]<=right[0] else right.pop(0))
    listone.extend(right if right else left)
    return  listone
data_lst = [6,202,100,301,28,8,1]
print(merage_sort(data_lst))

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
[1, 6, 8, 28, 100, 202, 301]

6.

7.  print('a'<'b'<'c') 输出为True

8.

x=156
ch='A'
y=1
print(x>=y and ch<'b' and y)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>
1

9.

name="Mike"
u = name[-2:]
print(u)
#>>>>>>>>>>>>>>>>>>>>>
ke

10.开根号，math.sqrt(x),求x的平方根例如math.sqrt(25)=5

11.给定一个字符串S，要求把S的前k个字符移动到S的尾部，如把字符串“abcdef”前面的2个字符‘a’、‘b’移动到字符串的尾部，得到新字符串“cdefab”，称作字符串循环左移k位。

# 循环左移
def str_rol(s, n):
    t = n % len(s)
    return s[t:] + s[:t]
 
# 循环右移
def str_ror(s, n):
    length = len(s)
    t = n % length
    return s[length - n:] + s[:length - n]
  
# 测试
    S = 'abcXYZdef'
    print(str_rol(S, 2))
    print(str_ror(S, 1))
#改成输入-----------------------------------------
s = str(input("s:"))
n = int(input("n:"))
# 循环左移
def str_rol(s, n):
    t = n % len(s)
    return s[t:] + s[:t]
 
# 循环右移
def str_ror(s, n):
    length = len(s)
    t = n % length
    return s[length - n:] + s[:length - n]
  
# 测试    
print(str_rol(s, n))
print(str_ror(s, n))

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
s:asdfghjj
n:2
dfghjjas
jjasdfgh

12.round(x,2)四舍五入保留小数，例如：print(round(12.2543,2))，输入12.25，四舍五入保留2位小数

x是需要处理的数值，而后面的参数用来保留几位小数，round(x,3)就四舍五入保留3位小数

13.输入直角三角形两直角边a,b的值，输出斜边上的高

import math                         #使用math必须导入math
a=int(input("请输入第一条直角边："))
b=int(input("请输入第二条直角边："))
c=round(math.sqrt(a**2+b**2),2)     #math.sqrt求平方根，c**2=a**2+b**2。round(x,2)让这个平方根保留2位小数
print("第三条斜边的长度等于："+str(c))

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入第一条直角边：4
请输入第二条直角边：5
第三条斜边的长度等于：6.4       #四舍五入保留两位小数应该等于6.40的，末尾的0给去掉了,,,,无语  

14.计算字符串最后一个单词的长度，单词以空格隔开。

可以使用split()方法，将文本内的每个单词分割，存储在一个单词列表里，

a=input("请输入一段英文：")
print("将这个句话分割成单词列表存储：")       #因为下面要输出的是列表，所以把这句话拿出来，不然要转换下面输出的格式
print(a.split())                     
print(len(a.split()[-1]))

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入一段英文：what do you mean
将这个句话分割成单词列表存储：
['what', 'do', 'you', 'mean']
4

15.接受一个由字母和数字组成的字符串，和一个字符，然后输出输入的字符串中含有该字符的个数。不区分大小写。

str1 = input("第一个字符串:").lower()
str2 = input("第二个字符:").lower()
print(str1.count(str2))         #网上看的方法：简简单单，只能说6！
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
第一个字符串:asdasfga
第二个字符:as                    #我这里第二个也输入了字符串
2

#按要求是一次输入-----------------------------------------------
s=input("请输入一个字符串和一个字符，中间用空格隔开：")
lis=s.split()                    #使用split()方法，将输入的两个字符存储到列表
print(lis[0].count(lis[1]))      #计数第二个字符在第一个字符中出现了多少次
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入一个字符串和一个字符，中间用空格隔开：ilove12you o
2

16.给出一个圆的半径，求出圆的周长和面积，使用 round(a,4) 函数保留4位小数，规定pi=3.14159

r=int(input("请输入圆的周长r:"))
pi=3.14159
print("圆的周长等于："+str(round(2*pi*r,4)))
print("圆的面积等于："+str(round(pi*r**2,4)))

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入圆的周长r:2
圆的周长等于：12.5664
圆的面积等于：12.5664

17.由三角形的三边长，求其面积。

规定：输入的三条边一定能构成三角形，不用进行判定。提示：a,b,c小于1000由三角形的三边a,b,c求面积可以用如下的公式：其中p=(a+b+c)/2             面积=S=√[p(p-a)(p-b)(p-c)]         请使用print('%.2f'%s)

#输入三边求面积s
a = int(input("请输入a："))
b = int(input("请输入b："))
c = int(input("请输入c："))
p = (a+b+c)/2
s = (p*(p-a)*(p-b)(p-c))**0.5     #开根号也=1/2次方，所以不用math.sqrt()方法也可**0.5
print('%.2f'%s)

#保留小数'%.2f'%s，其中f前数值为小数位数，s为数值
s1 = 5
s2 = 5.1
s3 = 5.1234
s4 = 5.6666
'%.1f'%s1 >>> 5.0 #保留一位小数
'%.2f'%s1 >>> 5.00 #保留两位小数
'%.2f'%s2 >>> 5.10 #保留两位小数
'%.2f'%s3 >>> 5.12 #保留两位小数
'%.2f'%s4 >>> 5.67 #保留两位小数，四舍五入

18.给出一个等差数列的前两项a1，a2，求第n项是多少

a1=1
a2=3
n=int(input("请输入n的数值："))
an=a1+(n-1)*(a2-a1)     #an=a1+(n-1)*d
print(an)

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入n的数值：5
9
请输入n的数值：3
5

19.切片使用，

截取列表中的任何部分。切片适用于列表、元组、字符串、range对象等类型。格式：[::]切片使用两个冒号分隔的3个数字来完成。

              第一个数字表示切片开始位置（默认为0）。

　　　　第二个数字表示切片截止（但不包含）位置（默认为列表长度）。

　　　　第三个数字表示切片的步长（默认为1），当步长省略是可省略最后一个冒号。

[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> alist[::-1]　　　#逆序的所有元素
[0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> alist[::2]　　　　#从0号位置开始，步长为2
[1, 3, 5, 7, 9]      
>>> alist[1::2]　　　　#从1号位置开始，步长为2
[2, 4, 6, 8, 0]

alist=[3,4,5,7,9,12,13,15,17]
blist=alist[3:7:2]              #后面的2带边步长，不指明的话默认为1
print(blist)

#>>>>>>>>>>>>
[7, 12]

20.在使用Python进行矩阵操作时，当内部含有除法时，会产生错误：TypeError: slice indices must be integers or None or have an __index__ method

由于除法/自动产生的类型是浮点型，因此出现上述错误，修正方法为，将/更改为//

例如在将列表添加到字典中的时候使用切片（过程中使用除法/），就需要改成//   参考下面的例子

 

21.对列表元素进行分类后加标签存入字典。

输入一个列表，要求列表中的每个元素都为正整数且列表包含的元素个数为偶数；

将列表中前一半元素保存至字典的第一个键值1中，后一半元素保存至第二个键值2中。

可以使用以下实现列表alist的输入：alist=list(map(int,input().split()))

alist=list(map(int,input().split()))    #这个方法可以输入一串数字，中间空格隔开就可生成数字列表
mid=len(alist)//2               #这里除法使用//
print(dict({'1':alist[:mid],'2':alist[mid:]}))  #使用dict()创建字典

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 2 3 4 5 6
{'1': [1, 2, 3], '2': [4, 5, 6]}

22.输入一个列表，将其反转后输出新的列表。两种方法：

1.直接使用切片
alist=list(map(int,input().split()))
print(alist[::-1])

2.使用reverse()反转
alist=list(map(int,input().split()))
alist.reverse()
print(alist)

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
1 2 3 4
[4, 3, 2, 1]

23.列表元素绝对值排序--------sorted(alist,key=abs)

输入一个列表，要求列表中的每个元素都为整数；将列表中的所有元素按照它们的绝对值大小进行排序，绝对值相同的还保持原来的相对位置，打印排序后的列表（绝对值大小仅作为排序依据，打印出的列表中元素仍为原列表中的元素）。

#排序就用sorted()，这里需要用sorted函数里的一个key的参数，abs就是绝对值
alist=list(map(int,input().split()))
print(sorted(alist,key=abs))      #重点就是sorted中key的参数abs

24.for--else语句意思是：直到....然后......。for语句执行完后还会执行else语句

for i in range(2):
    print(i, end='')
else:
    print(0)
#>>>>>>>>>>>>>>>>>>>>
010                    #先执行了for语句生成01，然后执行了else语句生成0

25.break中断问题示例：费解（不是说好break是直接退出循环嘛，但else并不在循环内）

发觉点什么后的自我解释：这个程序中好像没有要执行else代码块的逻辑

lst=[1,3,5,7]
for i in lst:
    print(i)
    if i>=5:
        break         #break后连else后面的都没输出
else:                 #这个else并不在if同一行，它都不在for循环里面   ？？？
    print('END')

#>>>>>>>>>>>>>>>>>>>>>>
1
3
5                   #然鹅并没有输出END

26.打印一定范围内的水仙花数：水仙花数是指一个n位数 (n≥3)，它的每个位上的数字的n次幂之和等于它本身。

水仙花数是指一个n位数 (n≥3)，它的每个位上的数字的n次幂之和等于它本身。例如：153是一个“水仙花数”，因为 153 是个 3位数，而1**3+5**3+3**3==153。输入一个正整数max，输出100到max之间的所有水仙花数（包括max）。

#输入一个数，判断100到这个数中所包含的水仙花数
max = input("请输入max：")
for i in range(100, int(max)+1):
    n = len(str(i))
    s = 0
    for j in str(i):
        s += int(j) ** n
    if s == i:
        print(s)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入max：500
153
370
371
407

27.输入两个字符串，输出两个字符串集合的并集,排序输出。

alist=list(map(int,input("请输入集合1：").split()))
blist=list(map(int,input("请输入集合2：").split()))
print(set(sorted(alist+blist)))

#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入集合1：1 2 3 4 5
请输入集合2：4 5 6 7 8
{1, 2, 3, 4, 5, 6, 7, 8}

28.与7相关的数：如果一个正整数，它能被7整除或者它的十进制表示法中某个位数上的数字为7，则称之为与7相关的数。

现在我们给定一个正整数n（n<1000），求所有小于等于n的与7无关的正整数的平方和。

n=int(input("请输入n："))
sum=0
for i in range(n+1):
    if i%7 != 0 and '7' not in str(i):#转化成字符串！！
        sum+=i**2
print(sum)

29.打印完数：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如 6 = 1＋2＋3。

题目：输入一个正整数n（n<1000），输出1到n之间的所有完数（包括n）。

#输入一个正整数n（n<1000），输出1到n之间的所有完数（包括n）：
a = int(input("请输入一个正整数："))
def fun(number):
    yinzi = []
    for m in range(2, number//2 + 1):
        if number % m == 0:
            yinzi.append(m)
        else:
            continue
    return yinzi

for i in range(5, a+1):       
    n = fun(i)
    if sum(n)+1 == i:
        print(i)

30.打印一个n层（1<n<20）金字塔，金字塔由“+”构成，塔尖是1个“+”，下一层是3个“+”，居中排列，以此类推。

注意：每一行的+号之后均无空格，最后一行没有空格。

a = int(input("请输入层数n："))
for x in range(1,a+1):
    print(' '*(a-x) + '+'*(2*x-1))
        
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入层数n：3
  +
 +++
+++++

31.给一个5位数，判断它是不是回文数，是则输出yes，不是则输出no。

例如12321是回文数，它的个位与万位相同，十位与千位相同。

n = str(input("请输入一个5位数："))
for i in range(0,len(n)):    # 从左往右依次提取数字内的每一个字符
    k = -1*(i+1)             # 从右往左依次提取，因此设置k与i的关系 
    if n[i] != n[k]:         # 依次对比左边和右边的字符，如果不相等
        print('no')          #print(no)后break该循环
        break
else:                        # 如果一直没有break，说明是回文数，print(yes)
    print('yes')

32.

输入一个列表alist，要求列表中的每个元素都为正整数且不超过10；

将列表中的奇数变为它的平方，偶数除以2后打印新的列表（新的列表中所有元素仍都为整数）。

#方法1：首先把输入的数字按空格分开变成一个列表，遍历列表里的元素，判断奇偶再进行相关操作
lst = list(map(int,input().split()))
a = []
for i in lst:
    if i % 2 ==0:
        a.append(i // 2)
    else:
        a.append(i**2)
print(sorted(a))

--------------------------------------------------------------------------
#方法2：直接改写列表元素
lst = list(map(int,input().split()))
for i in range(len(lst)):
	if lst[i] % 2 == 0:
		lst[i] //= 2
	else:
		lst[i] **= 2
print(sorted(lst))

33.打印一定范围内的素数

给定一个大于2的正整数n，打印出小于n（不包括n且n不大于100）的所有素数。

要求将符合条件的输出填入一个列表中，打印的结果为该列表。

def num(a):
    for i in range(2,a):
        if a%i==0:
            return False
    return True
#输入范围
n=int(input("输入取值范围1—"))
alist=[]
for i in range(2,n):
    if(num(i)):
        alist.append(i)
print(alist)

34.猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第n天（<1<n<11）早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

x = 1
n=int(input("n:"))
for i in range(1,n):
    x=(x+1)*2
print(x)

#>>>>>>>>>>>>>>>>>
n:10
1534

35.编写程序，创建类Temperature，其包含成员变量degree（表示温度）以及实例方法ToFahrenheit（将摄氏温度转换为华氏温度）和ToCelsius（将华氏温度转换为摄氏温度），并编写测试代码

class Temperature:
    def __init__(self, degree):
        self.degree = degree
    def toFahrenheit(self):
        return self.degree*9/5 + 32
    def toCelsius(self):
        return (self.degree -32) * 5/9

if __name__ == '__main__':
    n1 = float(input("请输入摄氏温度："))
    t1 = Temperature(n1)
    print("摄氏温度 = {0:.2f}， 华氏温度 = {1:.2f}".format(n1, t1.toFahrenheit()))
    n2 = float(input("请输入华氏温度："))
    t2 = Temperature(n2)
    print("摄氏温度 = {0:.2f}， 华氏温度 = {1:.2f}".format(t2.toCelsius(), n2))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
请输入摄氏温度：30
摄氏温度 = 30.00， 华氏温度 = 86.00
请输入华氏温度：70
摄氏温度 = 21.11， 华氏温度 = 70.00

36.斐波拉契数列：这个数列从第三项开始，每一项都等于前两项之和。

已知斐波拉契数列的前两项都是1，我们定义求斐波拉契数列的第n项（n<=50）的函数为fbnq，程序主体如下：

n=int(input(""))
print(fbnq(n))

#这题要求我们用函数, 不要用递归。因为递归太慢：
def fbnq(n):
    a,b= 1,1
    for i in range(n-2):
        a,b = b,a+b
    return b
n = int(input(""))
print(fbnq(n))

37.求两个数的最大公约数。

输入两个正整数num1和num2（不超过1000），求它们的最大公约数并输出。

我们定义求最大公约数的函数为hcf，给出程序主体如下：

num1=int(input(""))         num2=int(input(""))                 print(hcf(num1,num2))

num1 = int(input())
num2 = int(input())

def hcf(n1, n2):
    alist = []
    for i in range(1, min(n1, n2)+1):
        if n1 % i == 0 and n2 % i == 0:
            alist.append(i)
            gcd = int(max(alist))
    return gcd

print(int((num1*num2)/hcf(num1, num2)))

38.求两个数的最小公倍数。

输入两个正整数num1和num2（不超过500），求它们的最小公倍数并输出。我们定义求最小公倍数的函数为lcm，给出程序主体如下：

num1=int(input(""))

num2=int(input(""))

print(lcm(num1,num2))

num1 = int(input())
num2 = int(input())
def hcf(n1, n2):
    alist = []
    for i in range(1, min(n1, n2)+1):
        if n1 % i == 0 and n2 % i == 0:
            alist.append(i)
            gcd = int(max(alist))
    return gcd

print(int((num1*num2)/hcf(num1, num2)))

39.求阶乘

我们定义求n（n为正整数且n<=20）的阶乘的函数为fact，给出程序主体如下：

n=int(input(""))
print(fact(n))

#求阶乘
def fact(n):
    s = 1
    for i in range(1, n + 1):
        s *= i
    return s

n = int(input(""))
print(fact(n))

40.冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

已知输入为一个列表，列表中的元素都为整数，我们定义冒泡排序函数为bubbleSort，将列表中的元素按从小到大进行排序后得到一个新的列表并输出，给出程序主体如下：

alist=list(map(int,input().split()))                     print(bubbleSort(alist))

def bubbleSort(lst):
    for i in range(len(lst) - 1):
        for j in range(len(lst) - 1 - i):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
    return lst
alist = list(map(int, input().split()))
print(bubbleSort(alist))

41.已知输入为一个列表，列表中的元素都为整数，我们定义元素筛选函数为foo，功能是检查获取传入列表对象的所有奇数位索引（注意列表的索引是从0开始的）对应的元素，并将其作为新列表返回给调用者

def foo(alist):
    blist = []
    for i in range(len(alist)):
        if i%2!=0:
            blist.append(alist[i])
    return blist

alist=list(map(int,input().split()))
print(foo(alist))

42.输入年月日，判断这一天是这一年的第几天？给定年月日，如2019/1/8，打印输出这一天是该年的第几天。

from datetime import *
d=input()
d1=datetime.strptime(d[:4]+'/1/1','%Y/%m/%d')
d2=datetime.strptime(d,'%Y/%m/%d')
print((d2-d1).days+1)

43.公式求值

接受一个正整数输入x，打印上述公式的输出值。

import math
x = int(input())
print(round(math.sin(15*math.pi/180)+(math.exp(x)-5*x)/math.sqrt(x**2+1)-math.log(3*x),10))

44.一个特殊的正整数，它加上150后是一个完全平方数，再加上136又是一个完全平方数，求符合条件的最小的一个数。

i = 0
while True:
    if pow(int((i + 150) ** 0.5), 2) == i + 150 and pow(int((i + 150 + 136) ** 0.5), 2) == i + 150 + 136:
        print(i)
        break
    else:
        i += 1

45.约瑟夫环问题

已知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)

46.设计一个学生类(Student)，其中的数据成员有：字符串类型sname表示录入的学生姓名，整型值mscore代表学生的数学成绩，整型值cscore代表学生的语文成绩，整型值escore代表学生的英语成绩。

然后要求根据录入的学生成绩（各不相同），输出总分最高的学生姓名和各科目成绩。

输入分为4个部分：

先输入学生姓名，以空格分隔；

然后输入学生的数学成绩（各不相同的正整数），也以空格分隔；

再输入学生的语文数学成绩（各不相同的正整数），也以空格分隔。

最后输入学生的英语数学成绩（各不相同的正整数），也以空格分隔。

学生姓名个数和成绩个数一定会相同。

# 设计一个学生类(Student)，其中的数据成员有：
class Student:
# 字符串类型sname表示录入的学生姓名，
    def __init__(self,sname,msocre,cscore,escore):
        self.sname,self.msocre,self.cscore,\
            self.escore = sname,msocre,cscore,escore
        self.res = self.msocre + self.cscore + self.escore
# 整型值mscore代表学生的数学成绩，
# 整型值cscore代表学生的语文成绩，
# 整型值escore代表学生的英语成绩。
    def show(self):
        print('%s %d %d %d'%
              (self.sname,self.msocre,self.cscore,self.escore))
    def __lt__(self, other):
        return self.res < other.res

# 然后要求根据录入的学生成绩（各不相同）
# ，输出总分最高的学生姓名和各科目成绩。
name = input().split(' ')
mscore =list(map(int,input().split(' ')))
cscore = list(map(int,input().split(' ')))
escore =list(map(int,input().split(' ')))
list1 = list()
for i in range(0,len(name)):
    b = Student(name[i],mscore[i],cscore[i],escore[i])
    list1.append(b)
list1.sort()
list1[-1].show()

47.两数求和问题

给定一个列表和一个整数目标，其中列表中的元素都为整数，要求返回列表中的两个元素的索引编号（以列表形式打印,为确保结果唯一，小的编号在前），使这两个元素的和为这个特定的目标。(只对应确定的唯一一组解，并且不能使用同一个元素两次。)

lst = list(map(int, input().split()))
s = int(input())

def select(lst, s):
    for a in lst:
        for b in lst:
            if a != b and s == a + b:
                return sorted([lst.index(a), lst.index(b)])

print(select(lst, s))

48.精致的数

给定两个非负整数 x 和 y，如果某一整数等于x^i+y^j，其中整数 i >= 0 且 j >=0，那么我们认为该整数是一个"精致"的数。返回值小于或等于n(n<=200)的所有精致的数组成的列表。结果列表中每个值最多出现一次，同时请使用sorted保证结果唯一。

x, y, n = int(input()), int(input()), int(input())
def select(x, y, n):
    r = set()
    for i in range(n):
        for j in range(n):
            l = x ** i + y ** j
            if l <= n:
                r.add(l)
    return sorted(r)
print(select(x, y, n))

49.最大的周长

给定一个列表alist，alist由一些正整数（代表长度）组成，返回由alist中的三个长度组成的有效三角形的最大周长。如果所有的长度组合都不能构成有效三角形，则返回 0。

lst=list(map(int,input().split()))
def select(lst):
    tmax=0
    for i  in range(len(lst)):
        for j in range(i+1,len(lst)):
            for k in range(j+1,len(lst)):
                tri=sorted([lst[i],lst[j],lst[k]])
                if tri[0]+tri[1]>tri[2] and sum(tri)>tmax:
                    tmax=sum(tri)
    return tmax
print(select(lst))