Python经典练习题、面试题

1、定义任意4位数字，计算每一位数字的3次方之和。例如3456，即3**3+4**3+5**3+6**3

a=2345
str1=str(a)
sum=0
for i in str1:
    a=int(i)**3
    sum+=a
print(sum)

2、定义任意字符串，打印倒序字符串

a="123456789"
a1 = a[::-1]
print(a1)

3、定义任意字符串，打印从左向右奇数位字符组成的字符串

a="123456789"
a2=a[0::2]
print(a2)

4、定义任意字符串，打印从右向左奇数位字符组成的字符串

a="123456789"
a3=a[::-2]
print(a3)

5、定义任意字符串，打印从左向右偶数位字符组成的字符串

a="123456789"
a4=a[1::2]
print(a4)

6、定义任意字符串，打印从右向左偶数位字符组成的字符串

a="123456789"
a5=a[-2::-2]
print(a5)

7、定义任意数字，打印出倒序的数字 例如数字345 打印数字543

a="123456789"
a6=a[-5:-8:-1]
print(a6)

8、定义任意小数，小数点后必须有两位数字，计算小数部分数字的之和，例如：34.56，打印结果11

a=34.56
a=str(a)
a7=a[-1:-2:-1]
a7=int(a7) 
a8=a[-2:-3:-1]
a8=int(a8)
a9=a7+a8
print(a9)

9：
定义字符串：abcdefghigk
分别从键盘输入两个数字分别赋值给变量a、b，a表示起始索引，b表示终止索引
利用切片把索引[a,b]范围内的字符切出（a和b只考虑正数）

str='abcdefghigk'
a=int(input())
b=int(input())
str_1=str[a:b]
print(str_1)

10：从键盘输入任意字符串，再输入该字符串的字串，计算字串最后一个字符在原字符串中的索引值
例如：输入rerreet，再输入rre，打印字符串：rre最后一个字符正在字符串rerreet中的索引为4

a=str(input())
b=str(input())
c=a.find(b)
d=len(b)
print(c+d-1)

11：从键盘输入任意字符串，打印出升序排序后的字符串
        从键盘输入任意字符串，打印出降序排序后的字符串 

a=str(input())
b=sorted(a)
c=sorted(a,reverse=True)
print(b)
print(c)

12：将字符串"i am tom",转换为列表["mot","ma","i"]

str="i am tom"
str1=str[::-1]
list=str1.split()
print(list)

13：将列表["c","b","b","a","e"]和[1,2,3],组成字典:{"a":1,"b":2,"c":3}

list=["c","b","b","a","e"]
list2=[1,2,3]
list.sort()
list.pop(1)
d=dict(zip(list,list2))
print(d)

14：从键盘输入任意字符串，去除字符串中的重复字符后再从小到大排序再打印排序后字符串

a=str(input())
b=set(a)
c=list(sorted(b))
print(c)

15：打印字典中的最大值，例如字典{"a":3,"b":2,"c":5}，打印最大值5

dict={"a":3,"b":2,"c":5}
v=list(dict.values())
l=max(v)
print(l)

16：打印字典中的最大值对应的键，例如字典{"a":3,"b":2,"c":5}，打印c

dict={"a":3,"b":2,"c":5}
list1=list(dict.keys())
list2=list(dict.values())
a=max(list2)
b=list2.index(a)
c=list1[b]
print(c)

17：从键盘输入任意两个有相同字符的字符串，打印出相同字符串
        例如 输入 abcdef 和defgh ，打印字符串： abcdef和defgh的相同字符串时def

a=str(input())
b=str(input())
c=set(a)
d=set(b)
e=c&d
print(e)

18：定义任意字符串的组成的列表，计算列表中最长字符串的长度值
        例如['a','abc','abcde'],打印：最长字符串长度为5

list1=["1","a2c","abc34d5e"]
c=[]
for i in list1:
    b=len(i)
    c.append(b)
print(max(c)) 

19：定义任意列表，打印反置后的列表

list=[1,2,3,4,5,6,]
list1=list[::-1]
print(list1)

20：定义字符串abcdef和数字123456，打印字典{"a":6,"c":4,'e':2}

a="abcdef"
b='123456'
list=list(b)
list1=list[::-1]
c=a[::2]
d=list1[::2]
dict=dict(zip(c,d))
print(dict)

21：定义任意列表，打印从右向左偶数位元素组成的列表     

list=[1,2,3,4,5,6,7,8]
a=list[-2::-2]
print(a)

22：定义两个字符串abc和def和数字123456，打印字典{5:'b',3:'d',1:'f'}

a='abc'
a1='def'
b=a+a1
b2=b[1::2]
b3 =list (b2)
print(b3)
c=123456
c1=list(str(c))
print(c1)
c2=c1[-2::-2]
print(c2)
d=dict(zip(c2,b3))
print(d)

23：定义任意数字组成的列表，列表中数字有重复的，将列表中最大值及其个数组成字典打印

set1=set(a)
list1=set1
b=max(list1)
c=a.count(b)
d=list(str(c))
i=list(str(b))
dict1=dict(zip(i,d))
print(dict1)

24：定义任意数字组成的列表，列表中数字有重复的，将列表中最大值及其个数、次大值及其个数组成字典打印

a=['4','5','6','7','4','2','6','4','7','9','5','2','4','8','5']
set1=set(list(a))
list2=list(set1)
e=max(list2)
b=a.count(list2)
r=list(str(b))
d=dict(zip(list2,r))
c=sorted(set1)
del c[-1]
f=max(c)
h=c.count(f)
k=list(str(h))
d1=dict(zip(f,k))
d.update(d1)
print(d)

25：for循环遍历二维列表中的每一个数字：[[3,4,2],[5,6,7],[3,4,6]] ，打印三行

list1= [[3,4,2],[5,6,7],[3,4,6],4,5]
for li in list1:
    if type(li) is list:
        for l in li:
            print(l,end=" ")
        print()
    else:
        print(li)

26： 
       定义任意字符串，for循环打印从左向右奇数位字符
       定义任意字符串，for循环打印从右向左奇数位字符
       定义任意字符串，for循环打印从左向右偶数位字符
       定义任意字符串，for循环打印从右向左偶数位字符

str1 = 'asdfghjyuitr'
for i in range(0,len(str1),2):
    print(str1[i],end=" ")
print()
for i in range(-1,-(len(str1)+1),-2):
    print(str1[i],end=" ")
print()
for i in range(1,len(str1),2):
    print(str1[i],end=" ")
print()
for i in range(-2,-(len(str1)+1),-2):
    print(str1[i],end=" ")
print()

27：打印菱形：
    *
   ***
  *****
   ***
    *

z=5
for i in range(-(z//2),z--(z//2)):
    if i<0:
        j=-i
    else:
        j=i
    print(' '*j+"*"*(z-2*j))

28： while循环猜数字，使用random.randint(0,100) 生成0-100内的随机数，从键盘输入数字猜这个随机数，如果猜错了就一直猜下去，并且提示猜大了或猜小了，如果猜对了就停止猜测。

import random
n = random.randint(0,100)
m = int(input("猜："))
while m!=n:
    if m>n:
        print("猜大了")
    else:
        print("猜小了")
    m = int(input("再猜："))
print("猜对了")

29： 定义函数dict_sort(dic:dict,key_value:bool,reverse:bool)，是先功能是对任意字典按照键的大小或值的大小排序，返回排序后的字典。key_value 为True 按照键排序，为False按照值排序，reverse为True降序，reverse为False升序。默认按照键升序排序。

def dict_sort(dic:dict,key_value:bool=True,reverse:bool=False):
    if key_value is True:
        a=0
    else:
        a=1
    list_key_v = list(dic.items())
    lam3 = lambda tup1: tup1[a]
    new_list = sorted(list_key_v, key=lam3, reverse=reverse)
    new_dict = dict(new_list)
    return new_dict

if __name__=="__main__":
    r=dict_sort({'b':4,'d':1,'a':7,'e':3})
    print(r)

30：将字符串："姓名,马云,性别,男,身高,180"转换为字典{"姓名":"马云","性别":"男","身高":"180"}

a="姓名,马云,性别,男,身高,180"
b=a.split(",")
list1=b[::2]
list2=b[1::2]
c=dict(zip(list1,list2))
print(c)

31、打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数（100-999），其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

for i in range(100,1000):
    str1=str(i)
    a=0
    for k in range(3):
        b=int(str1[k])**3
        a=a+b
    if a==i:
        print('水仙花数为%d' % (i))

32：定义函数find_sum(li:list,sum:int),实现功能是对于任意数字列表，找到列表中两两相加等于sum的数字
例如： num_list=[3,2,4,7,1] sum=5,返回列表[[3,2],[4,1] ]

def find_sum(li:list,sum:int):
    c = []
    for i in range(len(li)-1):
        for j in range(i+1,len(li)):
            if li[i]+li[j]==sum:
                print(li[i],li[j])

                c.append([li[i],li[j]])
    return (c)

r=find_sum([3,2,4,7,1],5)
print(r)

33：while循环实现 定义函数find_sum(li:list,sum:int),实现功能是对于任意数字列表，找到列表中两两相加等于sum的数字
例如： num_list=[3,2,4,7,1] sum=5,返回列表[[3,2],[4,1] ]

def find_sum(li:list,sum:int):
    c=[]
    i=0
    while i<len(li)-1:
        j=1+i
        while j<len(li):
            if li[i]+li[j]==sum:
                print(li[i],li[j])
                c.append([li[i],li[j]])
            j += 1
        i += 1
    return c

if __name__=="__main__":
    r=find_sum([3,2,4,7,1],5)
    print(r)

34：对于任意数字列表，找出列表中重复个数最多的数字，打印数字及其个数。
例 list1 = [3,3,6,2,5,3,5,3,6,7,7,5,5] 打印[[3,4],[5,4]]

list1 = [3,3,6,2,5,3,5,3,6,7,7,5,5]
set_1=set(list1)
list2=list(set_1) 
list3=[]
for i in list2:
    a=list1.count(i)
    list3.append(a)
    b=max(list3)
    list4 = []
    for j in list2:
        if list1.count(j)==b:
            list4.append([j,b])
print(list4)

35：定义函数shuixianhua(n),n表示n位数。实现功能打印n位数中，每一位的n次方之和与数字本身相等的数字。
        例如shuixianhua(4)，表示打印1000-9999中数字本身与数字每一位的4次方之和相等的数字。
        如果n不是整数，爆出异常信息：输入非数字

def shuixianhua(n):
    if type(n) is not int:
        raise Exception("输入非数字")
    list1 = list(range(10 ** (n - 1), 10 ** n ))#N位数字中所有的数
    for i in list1:  #遍历所有数字
        str3 = str(i)  # 变字符串 ‘4567’
        s = range(n)  # 每一位数子 【0 1 2,3】
        w = 0
        for j in s:
            w1 = int(str3[j]) ** n
            w = w + w1
            if w == i:
                print(i)
    return


if __name__=="__main__":
   r=shuixianhua(4)

 36.定义函数 number_wei_jisuan(number).number表示任意整数 在函数内首先判断number是否为整数，为整数进行以下计算： 例如：number值为234 则返回21（2的三次方+3的2次方+4的1次方） number值为23432则返 回328（2的五次方+3的四次方+4的3次方+3的2次方+2的1次方）

def number_wei_jisuan(n):                 #23432
    if type(n) is not int:                 #54321
       raise Exception("输入非数字")  #索引01234
    n=234
    a=str(n)
    list1=list(map(int,a))  # 变为数字列表
    list2=list(range(len(a)))   #数字列表的索引
    c=0
    for i in list2:
        a=list1[i]**int(len(list2)-i)
        c=c+a
    print(c)
if __name__=="__main__":
   r=number_wei_jisuan(5)

 37.  将有任意整数和负数组成的列表，分成整数一个列表，负数一个列表

list1=[1,2,3,4,5,-2,-4,-6,-3]
a=[]
b=[]
for i in list1:
    if i>0:
        a.append(i)
    else:
        b.append(i)
print(a)
print(b)

38.将列表[3,4,5,6]和[-7,-8,-9,-1]组合成列表[3,-7,4,-8,5,-9,6,-1]

a=[3,4,5,6]
b=[-7,-8,-9,-1]
new_list=[]
for i in range(4):
    new_list.append(a[i])
    new_list.append(b[i])
    a.insert(i*2+1,b[i]) 
print(a)

39.有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

n=0
for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            if i!=j and j!=k and i!=k:
                n+=1 
print(n)

40.定义函数count_day(y,m,d),y,m,d分别是年月日，输入某年某月某日，返回这一天是这一年的第几天

def count_day(y,m,d):
   list1=[0,31,28,31,30,31,30,31,31,30,31,30,31]
   day=0
   if y%400==0 or (y%4==0 and y%100==0):
       list1[2]=list1[2]+1
   for i in range(m):
        day+=list1[i]
   print('%d年的第%d天'%(y,day+d))
if __name__ == '__main__':
    r=count_day(2020,3,18)

41.有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。

x=2
y=1
sum1=0
for i in range(21):
    sum1=sum1+x/y
    x=x+y
    y=x-y
    print(sum1)

42.求1+2!+3!+...+20!的和

def jiecheng(n):
    if n == 1:
        return 1
    return n*jiecheng(n-1)
if __name__=='__main__':
    r=jiecheng(20)
    print(r)

43.两个 2 行 2 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵： 例如：[[1,2],[3,4]] [[5,6],[7,8]] 得到[[6,8],[10,12]]

list1=[[1,2],[3,4],[5,6],[7,8]]
c=[[0,0],[0,0]]
c[0][0]=list1[0][0]+list1[2][0]
c[0][1]=list1[0][1]+list1[2][1]
c[1][0]=list1[1][0]+list1[3][0]
c[1][1]=list1[1][1]+list1[3][1]
print(c)

44.小明的身高是100，他有多个同学，每个同学都有一个身高，找出与小明身高相差绝对值一样的同学的身高，把这些身高按照相差绝对值（abs()函数）从小到大排序 xiaoming = 100 tongxue = [95,96,97,98,99,100,101,102,103,104,105] 打印结果为：99 101 98 102 97 103 96 104 95 105

tongxue= [95,96,97,98,99,100,101,102,103,104,105]
dict1={}
dict2={}
for i in tongxue:
    dict2={(i,abs(i-100))}
    dict1.update(dict2)
dict1.pop(100)
r=sorted(dict1.items(), key=lambda x: x[1],reverse=False)
dict3=dict(r)
list1=list(dict3.keys())
print(list1)

45.对于任意字符串，找出连续重复最多的字符重复次数。 # 例如：sdfsssssdfgdddddddswew，得到7（d重复7次）

str1='sdfsssssdfgdddddddswew'
x=1
c = 0
for i in range(len(str1)-1):
    if str1[i] == str1[i+1]:
        x=x+1
    else:
        c = max(x,c)
        x =1
print(c)

46.有一个字符串，其中包含数字、空格，组成有标签，数字个数和数字循环组成，标签唯一
例如：30 2 3 4 31 1 4 32 3 4 5 6 33 2 7 8
其中
30是标签，2是数字个数，3 4为2个数字
31是标签，1是数字个数，4 是1个数字
32是标签，3是数字个数，4 5 6是3个数字
33是标签，2是数字个数，7 8 是两个数字
练习1，当输入标签，打印该标签对应的数字，例如输入32 打印：4、5、6
练习2，当输入标签，计算该标签是列表中第几个标签，例如输入32 打印：3

list1= [30, 2, 3, 4 ,31 ,1 ,4 ,32, 3, 4 ,5, 6, 33, 2, 7, 8]
x=32 #输入的值
start=len(list1)
end=0
for i in range(len(list1)):
    if(list1[i]==x):
        start=i+2
        end=list1[i+1]+i+1#循环次数为 list[i+1] ，初始值为 i+2   ，依次输出 list[i+1] 个数
    if(i>=start and i<=end):
        print(list1[i])

47.对列表[[3,5,7],8,[2,9,6,4]]排序，排完后为[[2,3,4],5,[6,7,8,9]]

list1=[[3,5,7],8,[2,9,6,4]]
list2=[]
list3=[[],[]]
for i in list1:
    if type(i) is list:
        for j in i:
          list2.append(j)
    else:
        list2.append(i)
list2.sort(reverse=False)
for k in list2:
    if k<5:
        list3[0].append(k)
    elif k>5:
        list3[1].append(k)
list3.insert(1,5)
print(list3)

48.对由正负数组成的列表按照正负数间隔排序,\ 多出来的负数或正数添加在列表的后面

例如：[2,-3,-5,-13,4,6,12,-15,7,9] 排序后为[2,-3,4,-5,6,-13,12,-15,7,9] [-12,2,-3,-5,-13,4,6,12,-15,-24,-33,-39] 排序后为[-12,2,-3,4,-5,6,-13,12,-15,-24,-33,-39,2,5,8,9,5]

list1=[-12,2,-3,4,-5,6,-13,12,-15,-24,-33,-39,]
list2=[]
list3=[]
new_list=[]
for i in list1:
    if i>0:
        list2.append(i)
    elif i<0:
        list3.append(i)
if len(list2)>len(list3):
    for j in range(len(list3)):
       list2.insert(j*2+1,list3[j])
    print(list2)
else:
    for k in range(len(list2)):
        list3.insert(k*2+1,list2[k])
    print(list3)