全国青少年软件编程python四级（2021.9备考1）

: 梁老师北京小升初老师～

0 人点赞了该文章 · 48 浏览

1.写函数，接收n个数字，求这些参数数字的和

def sum_func(*args):     sm = 0     for i in args:         sm += i     return sm print(sum_func(*(1,2,3,7,4,5,6)))print(sum_func(*[1,2,3,7,4,5,6]))print(sum_func(1,2,3,7,4,5,6))
#结果28

2.找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表

 l1 = [1,2,3,4,5,6,7] def jishu_list(l,li = []):      n = 1      for i in l:         if n%2 == 1:              li.append(i)          n += 1      return li print(jishu_list(l1))
#结果：[1, 3, 5, 7]

3.写一个函数，判断用户传入的对象（不可哈希）长度是否大于5

def func(l):     # return True if len(l) > 5 else False     return len(l) > 5 #比较运算本身返回bool值print(func('546646'))#结果：True

4(1).写一个函数，判断用户传入的列表长度是否大于2，如果大于2，只保留前两个，并将新内容返回给调用者

def func(l):      if len(l)>2:          l = l[0:2]          return l      else:          return l  print(func([1,2,3,4]))  print(func([1,2])) #结果：[1, 2]#      [1, 2]

4(2).写函数，检查传入字典的每一个value长度，如果大于2，

那么仅保留前两个长度的内容，并将新内容返回给调用者

 dic = {"k1":"v1v1","k2":[11,22,33,44]}  def length_func(l):     for k,v in l.items():         if len(v) > 2:             i = v[0:2]             l[k]= i         else:             print('值长度小于2')     return l print(length_func(dic))
 #结果：{'k1': 'v1', 'k2': [11, 22]}

5.写函数，统计字符串中有几个字母，几个数字，几个空格，几个其他字符，并返回结果

s = ' das1 32 a2da'def lei(l):     num = 0      isah = 0      kong = 0      other = 0      for i in l :          if i.isdigit():              num +=1         elif i.isalpha():             isah +=1         elif i.isspace():             kong +=1         else:             other +=1     return num,isah,kong,other print(lei(s))　
#结果：(4, 6, 3, 0)

6.写一个函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空

  def func(l):      if len(l) == 0:          return '该对象为空'      else:          return '该对象不为空'    print(func((1,2,3)))  print(func([]))  #结果：该对象不为空#     该对象为空

7.写函数，接收两个数字参数，返回比较大的数字

 def my_max(a,b):     return max(a,b)
print(my_max(5,8))#结果：8
max(1,2,1,3)#3max([1,2,1,3])#3max((1,2,1,3))#3max("1314")#"4"

8.python函数参数类型及其顺序

def f(a,b=5,*c,**d):  print(a,b,c,d)f(10,20,30,40,x1=50,x2=60)
#10 20 (30, 40) {'x1': 50, 'x2': 60}

9.编写程序，求1~n之间的素数列表

def sushu(x):    for i in range(2,x):        if x % i ==0:            return False            break      return True n=int(input("请输入n:"))for j in range(2,n):    if sushu(j)==True:        print(j,"是素数")

10.编写程序，生成一个包括100个随机整数的列表

s=[]i=0for i in range(0,30):    s.append(random.randint(1,10000))for i in range(0,30):    print(s[i],"  ",end='')    if i % 10 ==0:        print("\n")

11.编写程序，当用户从键盘输入整数后，对其进行因式分解(即素数的积)。如100=2*2*5*5

n = int(input("请输入待分解的整数n=?"))x = 1flag = Trueif n > 1000:#判断大于1000的数    print("请输入不超过1000的整数")if n > 1 and n <= 1000:    print("{}=".format(n), end='')    while n != 1:        x += 1        while n % x == 0:            n /= x            if flag:                flag = False                print(x, end='')            else:                print("*{}".format(x), end='')elif n == 1:    print("1=1")elif n == 0:print("0=0")

12.编写程序，验证100以内整数的哥德巴赫的猜想：任何一个充分大的偶数（大于等于6）总可以表示成两个素数之和。如10=5+5, 12=5+7

x=int(input("输入大于或等于6的偶数")) for n in range(3,x,2):        if isprime(n) and isprime(x-n):            print(x,'=',n,'+',x-n)

13.编写程序，输出所有由1、2、3、4这4个数字组成的素数，并且在每个素数中每个数字只使用一次。

def exercise3_5():    s=0    for i in range(1,5):        for j in range(1,5):            for k in range(1,5):                for l in range(1,5):                    if (i!=j) and (i!=k) and (i!=l) and (j!=k) and (j!=l) and (k!=l):                        s=i*1000+j*100+k*10+l                        if isprime(s)==True:                            print(s)exercise3_5()

14.编写程序，求所有水仙花数。水仙花数是指一个三位数，其个位、十位、百位3个数字的立方和等于这个数本身。并断定有没有四位数的水仙花数？

t=0

s=0 #统计水仙花数的个数

for i in range(100,1000):    j=int(i/100)    k=int((i-100*j)/10)    l=i-j*100-k*10    if i==j*j*j+k*k*k+l*l*l:        print(i)        s+=1print(s)
for i in range(1000,10000):    j=int(i/1000)    k=int((i-1000*j)/100)    l=int((i-j*1000-k*100)/10)    m=i-1000*j-100*k-10*l    if i==j*j*j*j+k*k*k*k+l*l*l*l+m*m*m*m:        t+=1        print(i)if t==0:    print("No such number")

15.编写程序，生成一个包含100个随机数的列表，然后运用切片方法对其中偶数下标的元素进行降序排列，奇数下标的元素不变。

解法一：import randomlist_1=[]#生成随机整数列表for i in range(20):    list_1.append(random.randint(0,100))    print('生成的列表为:',list_1)    #从首位开始索引下标为偶数位元素for i in range(0,len(list_1),2):        #从上一个偶数位的下一个偶数位元素开始索引    for u in range((i+2),len(list_1),2):            #防止索引超出范围        if i< len(list_1)-2:                #比较索引元素大小            if list_1[i]<=list_1[u]:                    #互换元素位置                list_t=list_1[i]                list_1[i]=list_1[u]                list_1[u]=list_tprint('排序后列表为:',list_1)
解法2：import randomrandom.seed()lst=[random.randint(0,101) for i in range(20)]print(lst)
def bubble_sort(lst):    n=len(lst)    for i in range(n//2):        for j in range(0,n-i-2,2):            if lst[j]<lst[j+2]:                lst[j],lst[j+2]=lst[j+2],lst[j]bubble_sort(lst)print(lst)

16.编写程序，输入行数，输出一个如下图所示的由“*”构成的等腰三角形。

for i in range(6):    for k in range(5-i):        print(" ",end=" ")    for j in range(2*i+1):        print("*", end=" ")    print()

17.编写程序，A、B、C、D、E共5人夜里去捕鱼，很晚才各自找地方休息。日上三竿，A第1个醒来，他将鱼均分成5份，把多余的一条扔掉，拿走自己的一份。B第2个醒来，他也将鱼均分成5份，将多余的1条扔掉，拿走自己的一份。C、D、E如此类推。问他们合伙至少捕了多少条鱼？

解法一设总共捕了x条鱼，每个人看到的鱼共有Xn条， 则：X1=xX2=(X1-1)/5*4X3=(X2-1)/5*4X4=(X3-1)/5*4X5=(X4-1)/5*4其中，(Xn-1)%5=0必定成立，即题中所提到的，扔掉一条，取五分之一。那么就有x，使得递推所得到的项满足(Xn-1)%5=0即可。def fish(n, x):    if (x - 1) % 5 == 0:        if n == 1:            return 1        else:            return fish(n - 1, (x - 1) / 5 * 4)    return 0x = 6while True:    x += 5    if fish(5, x) == 1:        print(x)        breakfor i in range(1, 6):    print("第{0}人看到的鱼有{1}条".format(i, x))x = int((x - 1) / 5 * 4)

解法二  反向递推法：解决E和D的问题（规模为2），就可以解决D和C的问题，也就是E、D、C的问题（规模为3），最后解决所有问题。由X(n+1)=(Xn-1)/5*4得，Xn=X(n+1)*5/4+1
fish = [0, 0, 0, 0, 1]i = 0while True:    fish[4] += 5    for i in range(3, -2, -1):        if fish[i + 1] % 4 != 0:            break        fish[i] = int(fish[i + 1] * 5 / 4 + 1)        if fish[i] % 5 != 1:            break    if i==-1:        breakprint("总共捕了",fish[0],"条鱼")for i in range(0, 5):print("第{0}人看到{1}条鱼".format(i+1, fish[i]))

18.编写程序，计算斐波拉契数列的后项与前项的比：1/1，2/1，3/2，5/3，8/5，13/8，......第n项的值，并观察随着n的增加，比值趋向什么值？

def fblq(x):    if x==1 or x==2:        return 1    else:        return fblq(x-1)+fblq(x-2)for k in range(1,30):    print(fblq(k+1)/fblq(k))

19.编写程序，计算卢卡斯数列的后项与前项的比：1/2，3/1，4/3，7/4，11/7，18/11，......第n项的值，并观察随着n的增加，比值趋向什么值？

卢卡斯数列的定义为：L(1)=2,L(2)=1,L(n)=L(n-1)+L(n-2) (n>=2),前9个数为：2、1、3、4、7、11、18、29、47

def LKS(x):    if x==1:        return 2    elif x==2:        return 1    else:        return LKS(x-1)+LKS(x-2)
for k in range(1,30):    print(LKS(k+1),"/",LKS(k),"=",LKS(k+1)/LKS(k))

20.用于判断输入的字符串是否由字母和数字构成，并统计字符个数。

sum_d=0sum_alpha=0#s="123 abc def 中klGD国  abcde 伟大"s=input("请输入字符串:")for i in range(0,len(s)):    if '0'<=s[i]<='9':        sum_d+=1    elif 'a'<=s[i]<='z':        sum_alpha+=1print(sum_d,sum_alpha)

21.编写程序，计算字符串中单词的个数。

str = input("请您输入一串字符串：")str1 = str.strip() # 去掉字符串前后空格index = 0count = 0while index < len(str1):    while str1[index] != " ": # 当不是空格是，下标加1        index += 1        if index == len(str1): # 当下标大小跟字符串长度一样时结束当前循环            break    count += 1  # 遇到空格加1    if index == len(str1): # 当下标大小跟字符串长度一样时结束当前循环        break    while str1[index] == " ": # 当有两个空格时，下标加1，防止以一个空格算一个单词        index += 1print("输入的字符串中一共有count = %d个单词" % count)

22.编写程序，用户输入一个字符串，将偶数下标位的字符提出来合成一个串A，再将奇数下标位置的字符提取出来合成串B，再将A和B连接起来输出。

c=input("请输入字符");A=""B=""for  a in c[::2]:    A=A+afor b in c[1:len(c):2]:    B=B+bn=A+Bprint(n)

23.编写程序，统计字符串中出现的每个字母出现次数，并输出成一个字典，如{‘a’:3,’A’:5,’b’:2}

#a = "aAsmr3idd4bgs7Dlsf9eAF"a=input("请输入字符串：")def fun1_2(x):     num = []    dic = {}    for i in x:        if i.isdigit():  #判断如果为数字，请将a字符串的数字取出，并输出一个新的字符串            num.append(i)        else:   #2 请统计a字符串出现每个字母的出现次数（忽视大小写），并输出一个字典。例：{'a':3,'b':1}            if i in dic:                        continue            else:                dic[i] = x.count(i)      new = ''.join(num)    print ("the new numbers string is: " + new)    print ("the dictionary is: %s" % dic)fun1_2(a)

24.编写程序，统计字符串中出现的每个单词出现次数，并输出成一个字典。

解法一str1 = "tomorrow is a good day tomorrow is a bad day tomorrow is a sunny day"list1 = str1.split(" ")dict1 ={}for element in list1:    if element not in dict1:        dict1[element] = 1    else:        dict1[element] += 1print(dict1)


解法二str1 = "tomorrow is a good day tomorrow is a bad day tomorrow is a sunny day"list1 = str1.split(" ")dict1 ={}for element in list1:    value = dict1.get(element)            #如果不存在则返回None    if value == None:        dict1[element] = 1    else:        dict1[element] += 1print(dict1)

25.编写程序，将输入的一串字符从前到后每个字符向后移动一位，最后一个字符存放到第一个位置，并输出结果。

arr=[]r=""m=input("请输入")for string in m:    arr.append(string)last=arr[-1]arr.insert(0,last)arr.pop()for str in arr:    r=r+strprint(r)

26.编写程序，把一段英文中字母“a”改写成“A”

#输入一串字符，将大写字母转换成小写字母，小写字母转换为大写字母def LtoU():    a = input("请 输入字符：")    b = []    for n in a :       if "a"<= n <= "z":          b.append(n.upper())       elif"A" <= n <= "Z" :          b.append(n.lower())       else:          b.append(n)    print("".join(b))def aToA():    a = input("请 输入字符：")    b = []    for n in a :       if n == "a":          b.append(n.upper())       else:          b.append(n)    print("".join(b))  aToA()

27.编写程序，把一段英文中每句话的首个单词的第一个字母改为大写。

def convert_initial(old: str) -> str:    new = ""    i = 0    while i < len(old):        if (i == 0) or (old[i - 1] == " "):            new += old[i].upper()        else:            new += old[i]        i += 1
    return new#print(convert_initial("I am a teacher, and you are student."))s=input("请输入一个英文句子:")print(convert_initial(s))

28.编写程序，将一段英文中有连续重复的单词只保留一个。

l = []s = "hello world hello python"for i in s.split(" "):if i not in l:l.append(i)
result = " ".join(l)print(result)
print()
def onlyOne(x):    m=[]    print(x)    for j in x.split(" "):        if j not in m:            m.append(j)    result =" ".join(m)    return resultt=input("请输入一个英文句子：")print(onlyOne(t))

29.编写程序，要求输入一段英文，以及此段中的一个单词和另外一个单词，然后显示用第二个单词替换第一个单词后的句子。

str='The weather today is really good.'fword=input('请输入要查找的单词')rword=input('请输入要替换的单词')c=str.count(fword)if c>0:    str=str.replace(fword,rword)    print('替换后的句子为：',str)else:    print('句子中没有要查找的单词')

30.编写自定义函数，实现从屏幕输入3个数，并求出其中最大值。

def myfun():    s=[]    for i in range(0,3):        t=int(input("请输入一个数："))        s.append(t)    print(max(s))    print(s)myfun()

31.编写函数，模仿内置函数sort()

s=[1,-3,2,6,8,11,-5,28,88]t=[]def mysort(x):    for i in range(0,len(x)):        t.append(min(x))        x.remove(min(x))    return tprint(mysort(s))

32.编写函数，求出之和，函数形参为n，n由用户在主函数中输入。

def jiecheng(x):    if (x==0) or (x == 1):        return 1    else:        return x*jiecheng(x-1)def mySum(n):    mysum=0    for i in range(0,n+1):        mysum+=1/jiecheng(i)    return mysum
k=int(input("请输入一个数："))print(mySum(k))

33.编写程序，运用递归方法判断一个数是否为回文数。

a = input("请输入一个数:")if a.isdigit():      a = str(a)      for i in range(len(a)):          if a[i] == a[len(a)-i-1]:              print(a,"是回文数")          else:              print(a,"不是回文数")          breakelse:      print("请输入自然数:")

34.编写程序，运用递归方法分别求出斐波拉契数列和卢卡斯数列前n项之和，n由用户在主函数中输入。

def fblq(x):    if (x==1) or (x == 2):        return 1    else:        return fblq(x-1)+fblq(x-2)
def LKS(x):    if x==1:        return 2    elif x==2:        return 1    else:        return LKS(x-1)+LKS(x-2)
def mySum(n):    fblqsum=0    lkssum=0    for i in range(1,n+1):        fblqsum+=fblq(i)        lkssum+=LKS(i)    return fblqsum,lkssum


k=int(input("请输入一个数："))print(mySum(k))

35.编写程序，研究算法的时间复杂度。比较不同的阶乘计算所耗费的时间。

import timestart=time.time()s=1for i in range(1,201):   s*=iprint(s)print("累乘用时:",time.time()-start)
def jiechen(x):    if x==0 or x==1:        return 1    else:        return x*jiechen(x-1)start=time.time()t=jiechen(200)print(t)print("递归用时:",time.time()-start)

36.递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归函数特性：

必须有一个明确的结束条件；

每次进入更深一层递归时，问题规模相比上次递归都应有所减少

相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。

递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

先举个简单的例子：计算1到100之间相加之和；通过循环和递归两种方式实现

# 循环方式 def sum_cycle(n):     sum = 0     for i in range(1,n+1) :         sum += i print(sum)
# 递归方式 def sum_recu(n):     if n>0:        return n +sum_recu(n-1)     else:        return 0 
sum_cycle(100) sum = sum_recu(100) print(sum)结果：

50505050

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

把上面的递归求和函数的参数改成10000就导致栈溢出！

RecursionError: maximum recursion depth exceeded in comparison

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

一般递归

def normal_recursion(n):    if n == 1:        return 1    else:        return n + normal_recursion(n-1)执行：

normal_recursion(5)5 + normal_recursion(4)5 + 4 + normal_recursion(3)5 + 4 + 3 + normal_recursion(2)5 + 4 + 3 + 2 + normal_recursion(1)5 + 4 + 3 + 35 + 4 + 65 + 1015

可以看到, 一般递归, 每一级递归都需要调用函数, 会创建新的栈,随着递归深度的增加, 创建的栈越来越多, 造成爆栈:boom:

尾递归

尾递归基于函数的尾调用, 每一级调用直接返回函数的返回值更新调用栈,而不用创建新的调用栈, 类似迭代的实现, 时间和空间上均优化了一般递归!

def tail_recursion(n, total=0):    if n == 0:        return total    else:        return tail_recursion(n-1, total+n)执行：

tail_recursion(5)tail_recursion(4, 5)tail_recursion(3, 9)tail_recursion(2, 12)tail_recursion(1, 14)tail_recursion(0, 15)15

可以看到, 每一级递归的函数调用变成"线性"的形式.

37.“吃饭，睡觉，打豆豆”是网络上最为流行的小笑话之一，这则笑话的具体内容如下。

有个记者去南极采访一群企鹅。

他问第一只企鹅：“你每天都做什么？”企鹅说：“吃饭，睡觉，打豆豆！”接着又问第二只企鹅：“你每天都做什么？”企鹅说：“吃饭，睡觉，打豆豆！”接着又问第三只企鹅：“你每天都做什么？”企鹅说：“吃饭，睡觉，打豆豆！”…记者带着困惑问其他的企鹅，答案都一样，就这样一直问了99只企鹅。当走到第100只小企鹅旁边时，记者问他：“你每天都做什么？”那只小企鹅回答：“吃饭，睡觉。”记者惊奇的又问：“你怎么不打豆豆？”小企鹅撇着嘴巴，瞪了记者一眼说：“我就是豆豆！”请编写一个程序，要求如下：

（1）编写一个函数用来描述记者与这100只企鹅对话的全过程，其输出格式为

（2）在主程序中测试该函数。

def interview():    for n in range(1, 100):        print('记者问第{}只企鹅：“你每天都做什么？”企鹅说：“吃饭，睡觉，打豆豆！”'.format(n))    print('记者问第100只企鹅：“你每天都做什么？”企鹅说：“吃饭，睡觉，我就是豆豆！”')

interview()

38.以下为输出韩国流行歌曲Nobady一段歌词（有修改）的代码，

请将上述代码中的重复部分抽象（定义）成一个函数，并在主程序中调用该函数，以使源代码显得更简洁一些。

def nobody(n):    for i in range(n):        print('I want nobody nobody but you')

nobody(2)print('How can i be with another')print("I don't want any other")nobody(3)

39.编写isOdd（）函数，该函数应有一个整数参数，如果该参数为奇数，函数返回True,否则返回Flase。最后在主程序中测试该函数。

def isOdd(n):    return n % 2 != 0

n = int(input('输入一个整数：'))print(f'{n}是奇数') if isOdd(n): else: print(f'{n}不是奇数')

40.若开始输入的x的值为正数，最后输出的结果为656，请编程输出符合条件的x的值。

def fun(n):    while (n - 1) / 5 > 0:        n = (n - 1) / 5    return n

print(fun(656))

41.2016年，微信朋友圈中曾疯传“手机尾号暴露你的年龄”，其算法如下：看一下你手机号的最后一位；把这个数字×2；然后加上5；再×50；把得到的数加上1766；用这个数-你出生的那一年，现在得到一个新的数字，该数的最后两位就是你的实际年龄。（本规则仅适用于年龄在100岁以内的人）。

现在，请解决以下问题：

（1）编写一个函数，该函数有两个参数：一个参数为手机号最后一位；另一个参数为四位数的出生年份该函数最后返回按照上述规则计算出来的年龄。

（2）在主程序中，测试该函数，该函数能正确反映出你的真实年龄吗？如果不能，如何修改计算规则？

def fun(m, n):    return ((m * 2 + 5) * 50 + 1766 - n) % 100

m = int(input('请输入手机号最后一位：'))n = int(input('请输入四位出生年份：'))print(fun(m, n))
（把1766改为1770）

42.编写一个程序，在主程序中求1900~2020年中所有的闰年，每行输出5个年份。闰年即能被4整除，但不能被100整除，或者能被400整除的年份。要求定义一个函数isLeap()，该函数用来判断某年是否为闰年，是闰年则函数返回True，否则返回Flase。

def isLeapYear(year):    return year % 400 == 0 or (year % 4 == 0 and year % 100 != 0)

count = 0for n in range(1900, 2021):    if isLeapYear(n) :        print(n, end='\t')        count += 1        if count % 5 == 0:            print()

43.编写一个函数，求一个正整数n的各位数字之和，并在主程序中测试该函数。

def fun(n):    sum = 0    for i in str(n):        sum += int(i)    return sum

def fun2(n):    ls = [int(c) for c in str(n)]    return sum(ls)

def fun3(n):    ls = list(map(int, str(n)))    return sum(ls)

count = 0n = eval(input('Enter a integer:'))print(f'{n}各位数之和为：{fun(n)}')print(f'{n}各位数之和为：{fun2(n)}')print(f'{n}各位数之和为：{fun3(n)}')

44.求出所有符合下列条件的三位正整数：分别乘以3、4、5、6、7后得到的整数的各位数字之和都相等。输入示例：

def fun(n):    ls = [int(c) for c in str(n)]    return sum(ls)

count = 0for n in range(100, 1000):    if fun(n) == fun(n * 3) == fun(n * 4) == fun(n * 5) == fun(n * 6) == fun(n * 7):        count += 1        print(f"x={n}: x*3={n * 3}, x*4={n * 4}, x*5={n * 5}, x*6={n * 6}, x*7={n * 7}")print(f"共有{count}个符合条件的三位数")

45.在主程序中输入一个整数n，判断该数是否为完数。所谓完数，是一些特殊的自然数，它所有的真因子（即除了自身以外的约束）的和，恰好等于它本身。如6=1+2+3,所以6是完数。要求定义一个函数，用来判断某个整数是否未完数，是完数则函数返回1，否则返回0。最后在主程序中测试该函数。

def fun(n):    s = 0    for i in range(1, n):        if n % i == 0:            s = s + i    return 1 if s == n else 0

def fun2(n):    ls = [i for i in range(1, n) if n % i == 0]    return 1 if sum(ls) == n else 0

n = int(input('请输输入一个整数：'))print(f'{n}是完数') if fun(n) == 1 else print(f'{n}不是完数')print(f'{n}是完数') if fun2(n) == 1 else print(f'{n}不是完数')

def fun(m, n):    ls = [i ** m for i in range(1, n + 1)]    return sum(ls)

print(fun(1, 100) + fun(2, 50) + fun(-1, 10))

47.

def fun(a, n):    s = 0    item = 0    for i in range(n):        item = item * 10 + a        s += item    return s

def fun2(a, n):    s = 0    for i in range(1, n + 1):        s += int(str(a) * i)    return s

def fun3(a, n):    ls = [int(str(a) * i) for i in range(1, n + 1)]    return sum(ls)

a, n = eval(input("输入a和n[用逗号分隔]:"))s = fun(a, n)print(f"若a={a}，n={n}，则s=a+aa+aaa+...+aaa...aaa={s}")s = fun2(a, n)print(f"若a={a}，n={n}，则s=a+aa+aaa+...+aaa...aaa={s}")s = fun3(a, n)print(f"若a={a}，n={n}，则s=a+aa+aaa+...+aaa...aaa={s}")

import random

def redPacket1(money=100, number=15):    ls = []    for n in range(number - 1):        lucky_money = random.uniform(0.01, money - (number - 1 - n) * 0.01)        lucky_money = round(lucky_money, 2)        ls.append(lucky_money)        money = money - lucky_money    ls.append(round(money, 2))    return ls

def redPacket2(money=100, number=15):    ls = []    for n in range(number - 1):        lucky_money = random.uniform(0.01, money / (number - n) * 2)        lucky_money = round(lucky_money, 2)        ls.append(lucky_money)        money = money - lucky_money    ls.append(round(money, 2))    return ls

def redPacket3(money=100, number=15):    money = money * 100    ls = []    for n in range(number - 1):        lucky_money = random.randint(1, int(money / (number - n) * 2))        ls.append(lucky_money / 100)        money = money - lucky_money    ls.append(money / 100)    return ls

a = redPacket1()print(a)print(sum(a))
a = redPacket2()print(a)print(sum(a))
a = redPacket3()print(a)print(sum(a))
a = redPacket3(1000)print(a)print(sum(a))
a = redPacket3(1000, 20)print(a)print(sum(a))
a = redPacket3(10, 6)print(a)print(sum(a))
# money = float(input('红包总金额：'))# number = int(input('红包数量：'))# print(redPacket(money, number))

49.编写一个函数isdiff（n)，用来判断参数n的各位数字是否互不相同，若互不相同，则返回1，否则返回0，并在主程序中测试该函数。

def isdiff(n):    s = str(n)    for i in s:        if s.count(i) > 1:            return 0    else:        return 1

def isdiff2(n):    a = str(n)    b = set(a)    return 1 if len(a) == len(b) else 0

n = int(input('请输入一个正整数：'))if isdiff(n) == 1:    print(f'{n}的各位数字互不相同')else:    print(f'{n}中有重复数字')
if isdiff2(n) == 1:    print(f'{n}的各位数字互不相同')else:    print(f'{n}中有重复数字')

50.编写一个函数，接受一个列表参数，函数返回该列表中所有正数之和。最后在主程序中测试该函数。

def fun(ls):    _ls = [i for i in ls if i > 0]    return sum(_ls)

def fun2(ls):    _ls = filter(lambda n: n > 0, ls)    return sum(_ls)

ls = eval(input('请按照列表格式输入列表元素：'))print(f'该列表中所有正数之和为：{fun(ls)}')print(f'该列表中所有正数之和为：{fun2(ls)}')

51.重复元素判定。编写一个函数，接受一个列表最为参数，如果一个元素在列表中出现了不止一次，则返回True，但不要改变源列表的值。最后在主程序中测试该函数。

def fun(ls):    for n in ls:        if ls.count(n) > 1:            return True    else:        return False

def fun2(ls):    return len(set(ls)) < len(ls)

ls = eval(input('请按照列表格式输入列表元素：'))if fun(ls) == True:    print('该列表中存在重复元素')else:    print('该列表中不存在重复元素')
if fun2(ls) == True:    print('该列表中存在重复元素')else:    print('该列表中不存在重复元素')

52.编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.

元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所

有数.

def cacluate(*args):    #接收任意多个数，输出为元组    avg = sum(args) / len(args)   #计算平均数    up_avg = []     #定义一个空列表，存放比平均值大的所有数    for item in args:    #遍历所有数        if item > avg:            up_avg.append(item)    #把比平均值大的加入到列表中    return avg,up_avg    #返回平均值，以及列表print(cacluate(1,2,3,4,5))    #调用函数执行结果：

53.编写一个函数, 接收字符串参数, 返回一个元组,‘ehllo WROLD’

元组的第一个值为大写字母的个数, 第二个值为小写字母个数.

代码如下：

def Fun(str):     #定义函数，接受一个字符串参数    upper = lower = 0     #定义计数器    for i in str:     #遍历字符串        if i.isupper():     #如果为大写字母，upper的值加一            upper += 1        elif i.islower():     #如果为小写，lower值加一            lower += 1        else:            continue     #既不是大写又不是小写，继续执行    return upper,lower     #返回大写和小写的数值print(Fun('HELLO westos!'))    #调用函数，其中！不包括在upper和lower的值中执行结果：

54.编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一

个整形数k, 返回一个新列表.

函数需求:

- 将列表下标k之前对应(不包含k)的元素逆序;

- 将下标k及之后的元素逆序;

[1,2,3,4,5] 2 [2,1,5,4,3]

代码如下：

import randomlist = []for i in range(30):    list.append(random.randint(1,100))      #生成一个有30个1～100随机数的列表print(list)
def Fun(list,k):    #传入两个参数    if k < 0 or k > len(list):    #判断传入的参数k值是否合法        return 'error'    #不合法返回error    else:        return list[:k][::-1] + list[k:][::-1]    #合法进行反转
print(Fun(list,9))   #调用函数执行结果：

55.

对于一个十进制的正整数，定义f(n)为其各位数字的平方和，如:

f(13) = 1**2 + 3**2 = 10

f(207) = 2**2 + 0**2 + 7**2 = 53

下面给出三个正整数k，a, b,你需要计算有多少个正整数n满足a<=n<=b,

且k*f(n)=n

输入:

第一行包含3个正整数k，a, b, k>=1, a,b<=10**18, a<=b;

输出：

输出对应的答案;

范例:

输入: 51 5000 10000

输出: 3

def f(n):    n = str(n)   #将数字转换为字符串    sum = 0    #定义计数器    for item in n:     #遍历字符串        sum += int(item) ** 2    #计算各位数字的平方和    return sum   #返回sum# print(f(207))
s = input()   #接受变量k,a,b
li = []  #存储变量k,a,b
for item in s.split():    li.append(int(item))k,a,b = li
count = 0# 判断是否满足条件for i in range(a,b+1):    if k*f(i) == i:        count += 1
print(count)执行结果：

56.汉诺塔问题：

复杂度：

f(n)=f(n-1)+1+f(n-1)

n层：2^n-1步

def func(n,fromm,to,help):    if n==1:        print("move"+" "+str(1)+" "+"from"+" "+fromm+" "+"to"+" "+to)#base case    else:        func(n-1,fromm,help,to)    #将n-1层从fromm挪到help        print("move"+" "+str(n)+" "+"from"+" "+fromm+" "+"to"+" "+to) #第n层单独挪动        func(n-1,help,to,fromm)    #将n-1层从help挪到func(3,"left","right","mid")

57.打印字符串的子序列：（顺序一样，可以不连续）

def func(arr,i,pre):    if (i==len(arr)):        if pre!="":            print(pre)        return    func(arr,i+1,pre+arr[i])    func(arr,i+1,pre)arr="abc"arr="".join(arr)func(arr,0,"")

58.打印字符串的全排列：（去重）

思想：

i位置把(i,n-1)位置所有字符尝试一遍(和每个位置交换)，位置之后的随机排列

def printAllPermutation(arr,i):    if i==len(arr):        print((''.join(arr)))    m=[]  #去重    for j in range(i,len(arr)):        if arr[j] not in m:  #去重            m.append(arr[j]) #去重            arr[i],arr[j]=arr[j],arr[i]            printAllPermutation(arr,i+1)            arr[i], arr[j] = arr[j], arr[i]
arr1=list("abc")arr2=list("acc")printAllPermutation(arr1,0)print("----------")printAllPermutation(arr2,0)

59.

有一只母牛，一年生一只母牛，新母牛三年后一年生一只母牛，母牛六年后死亡，N年后有多少只母牛？

思路：

f(n)=f(n-1)+f(n-3)-2*f(n-6) #减去6年前的母牛个数还有孩子个数，乘2

def count(n):    if n<1:        return 0    if n<=3:        return n    if n<6:        return  count(n-1)+count(n-3)    return count(n-1)+count(n-3)-2*count(n-6)print(count(7))

60.逆序一个栈（不占用额外空间）

def getandremovelastElement(stack): #得到栈底元素并返回    result=stack.pop()    if not stack:        return result    else:        last=getandremovelastElement(stack)        stack.append(result)        return lastdef reverse(stack):       if not stack:        return    i=getandremovelastElement(stack)    reverse(stack)    stack.append(i)s=[3,2,1]reverse(s)print(s)

1、局部变量

#全局变量school = 'ying gu xue xiao'#局部变量只在函数内生效
#这个函数就是这个变量的作用域def change_name(name):    #函数内修改全局变量    global  school    school = 'hei hou zi xue xiao'    print("before change",name)    name = "hei hou zi de jia"    print("after change",name)    print("school----",school)
name = "hei hou zi"change_name(name)print(name)print(school)打印
before change hei hou ziafter change hei hou zi de jiaschool---- hei hou zi xue xiaohei hou zihei hou zi xue xiao

2、全局变量

# 这种方式不要用， 容易直接被开除def ch_name():    #全局变量  使用global 关键字    global sex    sex = "女"
ch_name()print(sex)打印
女

3、局部变量修改全局变量

#除了 字符串  单独的整数这种， 局部不能直接修改全局变量， 列表、 字典 可以修改names = ["hei hou zi","Jack","Rain"]def change_name3():    names[0] = "victor"    print("inside func",names)
change_name3()print(names)打印
inside func ['victor', 'Jack', 'Rain']['victor', 'Jack', 'Rain']

1.什么是分治算法？

分治算法就是对一个问题采取各个击破的方法，将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。只要求出子问题的解，就可得到原问题的解。

2.为什么需要分治算法？

在编程过程中，经常遇到处理数据相当多、求解过程比较复杂、直接求解比较耗时的问题。

在求解这类问题时，可以采用各个击破的方法。

3.分治算法基础

具体做法是：先把这个问题分解成几个较小的子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个大问题的解。如果这些子问题还是比较大，可以继续把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治算法的基本思想

4.分治算法的解题一般步骤

（1）分解，将要解决的问题划分为若干个规模较小的同类问题。

（2）求解，当子问题划分得足够小时，用较简单的方法解决。

（3）合并，按原问题的要求，将子问题的逐层合并构成原问题的解。

5. 用分治算法--求顺序表中的最大值

# 基本子算法（子问题规模小于或等于2时）def get_max(max_list):    return max(max_list)

# 分治法def solve(init_list):    list_length = len(init_list)    # 若问题规模小于或等于2时，直接调用方法解决完成    if list_length <= 2:        return get_max(init_list)
    # 问题规模大时，开始分治算法的步骤    # 1.分解（子问题的规模为   n/2）,分别取列表其中的前半部分和后半部分    left_list = init_list[:list_length // 2]    right_list = init_list[list_length // 2:]
    # 2.分治、递归(一直递归，分解，知道求出前半部分的最大值，和后半部分的最大值)    left_max = solve(left_list)    right_max = solve(right_list)
    # 3.合并 （在把前半部分的最大值和后半部分的最大值做个比较，相当于求整个大数组的最大值）    return get_max([left_max, right_max])

if __name__ == '__main__':    test_list = [12, 6, 5956, 7, 8, 98, 46, 46, 4, 451, 9684, 4]    # 打印出最大值    print(solve(test_list))    # 9684

5. 用分治算法--判断某个元素是否在列表中

# 子问题算法（子问题规模为1）def is_in_list(init_list, el):    return [False, True][init_list[0] == el]

# 分治法def solve(init_list, el):    list_length = len(init_list)    if list_length == 1:  # 若问题规模等于1，即列表中        return is_in_list(init_list, el)
    # 分解（子问题规模为 n/2）    left_list = init_list[:list_length // 2]    right_list = init_list[list_length // 2:]
    # 分治合并  递归（一直进行拆分，   or 只有所有都是 False，才返回假 False）    # 所以只要有一个元素在里面，就判定元素在该列表中，    res = solve(left_list, el) or solve(right_list, el)
    return res

if __name__ == '__main__':    test_list = [12, 6, 5956, 7, 8, 98, 46, 46, 4, 451, 9684, 4]    # 查找    print(test_list)    print("判断45是否在列表中:", solve(test_list, 45))    print("判断4是否在列表中:", solve(test_list, 4))运行结果：

6. 用分治算法--找出一组序列中第K小的元素

# 划分（基于主元 pivot）def partition(seq):    pi = seq[0]  # 挑选主元    min_pi = [x for x in seq[1:] if x <= pi]  # 所有小于主元的元素    max_pi = [x for x in seq[1:] if x > pi]  # 所有大于主元的元素    return pi, min_pi, max_pi

# 查找第 K 小的元素def select(seq, k):    # 分解    pi, min_pi, max_pi = partition(seq)    min_pi_length = len(min_pi)  # 所有小于主元的元素长度    # 如果查第 k 小的元素刚好和 比主元小的元素列表长度 相等，则此时pi(主元)则刚好为第K小的元素    if min_pi_length == k:        return pi    # 长度小于k时，    elif min_pi_length < k:        # 分治、递归        return select(max_pi, k - min_pi_length - 1)    else:        # 分治、递归        return select(min_pi, k)

if __name__ == '__main__':    seq = [12, 6, 5956, 7, 8, 98, 46, 46, 4, 451, 9684, 4]    print(seq)    print("列表中第3小的：", select(seq, 3))    print("列表中第1小的：", select(seq, 1))

运行结果：

添加家长论坛微信

全国青少年软件编程python四级（2021.9备考1）

梁老师北京小升初老师～

8.python函数参数类型及其顺序

免责声明:

相关文章

全国青少年软件编程python四级（2021.9备考1）

梁老师 北京小升初老师～

8.python函数参数类型及其顺序

免责声明:

相关文章

梁老师北京小升初老师～