python入门题（计算机二级考试可用）.doc

Python入门 精选30题
考点：循环结构、分支结构
1、输入一个三位整数，判断这个数是不是“水仙花数”；所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数，例如：153=1^3 +5^3 +3^3 ，153 就是水仙花数。
n=eval(input())
i=n
a=0
while i:
a=a+(i%10)**3
i=i//10
if a==n:
print("yes")
else:
print("no")

2. 随机产生一个两位数的数字，然后用户输入一个两位数的数字，如果用户输入的数字与 随机产生的数字完全相同（包括顺序），则输出奖励 100 分；如果用户输入的数字与随机产生的数字相同（不包括顺序）， 则输出奖励 50 分；如果用户输入的数字与随机产生的数字有一位数相同，则奖励 10 分，如果都不相同，则输入没有奖励。
考点：产生随机数、取出一个整数各位上的数、分支结构
import random
a=random.randint(10,99)
b=eval(input())
a1=a%10
a2=a//10
b1=b%10
b2=b//10
if a==b:
print('100')
elif a1==b2 and a2==b1:
print('50')
elif a1==b1 or a2==b2 or a1==b2 or a2==b1:
print('10')
else:
print('0')

3.在金字塔模式中显示数字（编写一个嵌套 for 循环来显示下面的输出） ：
a=eval(input())
for i in range(a):
考点：循环结构、制表
if i==0:
for j in range(a-i):
print(' ',end='\t')
print('1',end='')
for j in range(a-i):
print(' ',end='\t')
print()
elif i!=0:
for k in range(a-i):
print(' ',end='\t')
for l in range(0,i+1):
a1=2**l
print(a1,end='\t’)
for y in range(i-1,-1,-1):
a1=2**y
print(a1,end='\t')
for x in range(a-i):
print(' ',end='\t')
print()

考点：素数、循环结构、分支结构
4、如果一个素数可以写成2^ p -1的形式，其中p为一个正整数，那么这个数被称作梅森素数。编写程序找出所有的p<= 31的梅森素数。
def issushu(n):
k=1
for i in range(2,n):
a=n/i
if a%1==0:
k=0
return False
if k==1:
return True
p=1
while p<=31:
a=(2**p)-1
p+=1
if issushu(a):
print(a,end=' ')

5、写一个函数计算下面的数列
考点：循环结构
+ + +
def m(n):
s=1
m=0
while s<=n:
a=s
s=s+1
m=m+(a/s)
return m

n=eval(input())
print(m(n))
考点：函数、循环结构、分支结构
6、神奇的 Collatz 序列。编写一个名为 collatz 的函数，它接收一个名为 number 的整数参数， 如果 number 是偶数，就打印 number//2，并返回该值。否则打印 3*number+1 并返回。同 时编写主程序，让用户输入一个整数，并不断地调用该函数（用第一次的返回值做第二次的参数，以此类推） ，直到函数返回 1. 例如用户输入 3 则打印输出应为
10
5
16
8
4
2
1
def collatz(number):
if number%2==0:
a=number//2
print(a)
return(a)
else:
b=number*3+1
print(b)
return(b)

number=eval(input())
while 1:
number=collatz(number)
if number==1:
break
7、一个数如果恰好等于它的除自身外的因子之和，这个数就称为“完数”。例如 6=1+2+3， 6 是完数。编写程序输出 1 至 1000 之间的所有完数。
考点：完数、print输出格式、循环结构、分支结构
def wanshu(n):
s=0
for i in range(1,n):
a=n/i
if a%1==0:
s=s+i
if s==n:
return True

for i in range(1,1001,1):
if wanshu(i):
print(i,end=' ')

考点：turtle内置函数
8、使用 turtle 绘制一个黄色边框的红色五角星。（五角星的每个内角均为 36°）
import turtle
turtle.showturtle
turtle.pensize(5)
turtle.color("yellow","red")
turtle.begin_fill()
for i in range(5):
turtle.forward(100)
turtle.right(144)
turtle.forward(100)
turtle.end_fill()
turtle.hideturtle

太阳花：
import turtle
turtle.pensize(3)
turtle.speed(10)
turtle.color('yellow','red')
turtle.begin_fill()
for i in range(30):
turtle.forward(100)
turtle.right(165)
turtle.forward(100)
turtle.end_fill()

9、使用 turtle 绘制奥运五环（蓝黑红黄绿）
import turtle
turtle.showturtle
turtle.pensize(10)
turtle.speed(10)
turtle.color("black")
turtle.penup()
turtle.goto(0,0)
turtle.pendown()
turtle.circle(100)

turtle.color("blue")
turtle.penup()
turtle.goto(-250,0)
turtle.pendown()
考点：turtle内置函数
turtle.circle(100)

turtle.color("red")
turtle.penup()
turtle.goto(250,0)
turtle.pendown()
turtle.circle(100)

turtle.color("yellow")
turtle.penup()
turtle.goto(-125,-70*(3**0.5))
turtle.pendown()
turtle.circle(100)

turtle.color("green")
turtle.penup()
turtle.goto(125,-70*(3**0.5))
turtle.pendown()
turtle.circle(100)

考点：循环结构、分支结构、输出格式
10、打印9*9乘法表

for i in range(1,10):
if i==1:
print("1 * 1 = 1")
else:
for j in range(1,i+1):
print(j,"*",i,"=",j*i,end="\t") #”\t”是制表符
print()

考点：循环结构求因子、分支结构、输出格式
11、编写程序读取一个大于1的正整数，然后显示它所有的最小因子，也称之为素因子（即将一个正整数分解质因数）。例如：输入整数为90，输出90=2*3*3*5。
n=eval(input())
print(n,end='=')
while n:
for i in range(2,n+1):
a=n/i
if a%1==0 and a!=1:
print(i,end='*')
break
elif a%1==0 and int(a)==1:
print(i,end='')
break
n=int(a)

12、从键盘输入整数n，输出数字方阵。例如：输入n=5，输出如下：
1 2 3 4 5
考点：循环结构、分支结构、制表
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4

n=eval(input())
for i in range(1,n+1):
for j in range(i,n+1):
print(j,end='\t')
if i==1:
print()
if i!=1:
for k in range(1,i,1):
print(k,end='\t')
print()

13、素数是指一对差值为2的素数。如3和5就是一对双素数。编写程序，输入正整数n，输出大于等于n的最小的一对双素数。
考点：循环结构、分支结构、素数
def issushu(n):
k=1
for i in range(2,n):
a=n/i
if a%1==0:
k=0
return False
if k==1:
return True

n=eval(input())
while 1:
if issushu(n) and issushu(n+2):
print(n,n+2,sep=' ')
break
else:
n=n+1

14、反素数（逆向拼写的素数）是指一个将其逆向拼写后也是一个素数的非回文数。例如：17和71都是素数，所以，17和71都是反素数。编写程序，输入一个正整数，显示大于该数的前10个反素数。
考点：函数：素数、回文数
def issushu(n):
a=True
for i in range(2,n):
if (n/i)%1==0:
a=False
return False
if a==True:
return True
def nixiang(m):
m=str(m)
m=m[::-1]
m=eval(m)
return m
def nothuiwenshu(s):
s=str(s)
if s==s[::-1]:
return False
else:
return True
z=eval(input())
s=0
while s<10:
z=z+1
if issushu(z) and issushu(nixiang(z)) and nothuiwenshu(z):
s+=1
if s<10:
print(z,end=' ')
elif s==10:
print(z,end='')
15、编写一个函数，计算一个整数各个数字的和。
使用下面的函数头：def sumDigits(n):
例如：sumDigits(234)返回9(2+3+4)。提示：使用求余运算符%提取数字，而使用除号//去掉提取出来的数字。使用一个循环来反复提取和去掉每个数字，直到所有数字被提取完为止。编写程序提示用户输入一个整数，然后显示这个整数所有数字的和。
考点：函数、求各位上的数
def sumDigits(n):
s=0
while 1:
a=n%10
s=s+a
n=n//10 #取出各位上的数的循环方法
if n==0:
return s

n=eval(input())
print(sumDigits(n))

16、通过键盘输入一串小写字母（a~z）组成的字符串，编写一个测试程序，将字符串中连续出现的重复字符删去（即在一个字符串中，如果遇到连续重复的字符只出现一次），然后输出处理后的字符串。例如：str1="aabbccddaabbccdd"，输出结果为："abcdabcd"。
考点：字符串、列表
a=input()
c=0
e=-1
k=list(a)
for i in a:
e+=1
b=ord(i)
if c==b:
k[e]=' '
c=b
k=[x for x in k if x!=' ']
k=''.join(k) #列表变字符串输出形式
print(k)

变形：输入一个字符串a，你需要通过将字符串中连续的字母表示为：字母+出现次数的方式来压缩这个字符串。例如 "aabcccccaaa"压缩输出成 "a2b1c5a3"。
x=input()
s=1
c=x[0] #初始字母，从此开始缩减字母显示次数
ss="" #创建空字符串
for i in range(1,len(x)):
if x[i] == c:
s += 1
else:
ss+=c+str(s)
c=x[i]
s = 1
ss+=c+str(s) #+号表示字符串连接
print(ss)
17、编写下面的函数合并两个有序列表构成一个新的有序列表：
def merge(list1,list2):
编写测试程序提示用户输入两个有序列表，然后显示合并后的升序列表。要求：不允许使用系统提供的sort方法。
考点：函数、列表
输入格式:两个有序列表（列表元素之间空格分隔，结尾无空格，回车换行输入下一个有序列表）
def merge(list1,list2):
list3=list1+list2
list31=[]
for x in list3:
x=int(x)
list31.append(x)
list31=sorted(list31,reverse=False)
return list31

a1=input()
b1=list(a1.split(' '))
a2=input()
b2=list(a2.split(' '))
print(merge(b1,b2))

18、输入30个数，输出其中最大的数。
考点：循环结构、列表与max函数
方法一
max1=0
for i in range(30):
x=eval(input())
if x>max1:
max1=x
print(max1)

方法二
a=[]
for i in range(30):
x=eval(input())
a.append(x)
max1=max(a)
print(max1)
考点：字符串、Unicode码与ord、chr函数
19、初始化一个小写英文字符串a和一个非负数b(0<=b<26), 将a中的每个小写字符替换成字母表中比它大b的字母。这里将字母表的z和a相连，如果超过了z就回到了a。例如a="cagy", b=3,则输出 ：fdjb.
a=input()
b=eval(input())
l=[]
for i in a:
x=chr(ord(i)+b)
if x>'z':
x=chr(ord(i)+b-26) #如果超过了z就回到了a
l.append(x)
l=''.join(l)
print(l)

20、输入一个字符串a和一个正整数n,判断a中是否存在长度为n的回文子串。如果存在，则输出YES，否则输出NO。
考点：字符串及其索引的应用
a=input()
b=eval(input())
c=len(a)
o=0
for i in range(c-b+1):
k=a[i:i+b]
if k==k[::-1] and len(k)==b:
o=1
print('YES')
if o==0:
print('NO')

21、N的阶乘定义为：N!=N×(N－1)×……×2×1
请编写一个程序，输出N的阶乘的十进制表示中从最末一个非0位开始自低位向高位数的第K位。现在给你N和K（0<=N<=10000，1<=K<=5），请你输出要求的数字(保证存在）。
例如：N=5,K=2,则输出1 note:（5!=120);
N=8,K=3,结果为0 note:（8!=40320）
考点：循环结构求阶乘、字符串索引、strip方法
N=eval(input())
K=eval(input())
jiecheng=1
if N>1:
for i in range(1,N+1,1):
jiecheng=jiecheng*i
x=jiecheng
w=str(jiecheng)
w=w.rstrip('0')
w=w[::-1]
k=w[K-1]
print(k)

22、编写函数 def repeat(string, n, delim)：
考点：循环结构、字符串、函数
返回string重复n次的字符串，并且使用字符串delim分隔。例如，repeat(“ho”, 3, “,”)返回“ho,ho,ho”
def repeat(string,n,delim):
x=""
for i in range(n):
x=x+string+delim
return x

string=input()
n=eval(input())
delim=input()
print(repeat(string,n,delim))

考点：循环结构、列表及其内置函数、函数
23、编写函数def merge(a, b)，合并两个列表，其中元素交替来自于两个列表。如果一个列表比另一个短，则把短的处理完，然后追加长列表中的剩余元素。
def merge(a,b):
c=[]
l1=len(a)
l2=len(b)
if l1==l2:
优化答案
def merge(a, b):
l=[]
for i in range(min(len(a),len(b))):
l.append(a.pop(0)) #把列表a开头第一个元素删除并将返回值添加到列表l中
l.append(b.pop(0))
l.extend(a) #把列表a添加到列表l的尾部
l.extend(b)
return l
for i in range(l1):
c.append(a[i])
c.append(b[i])
elif l1<l2:
for i in range(l1):
c.append(a[i])
c.append(b[i])
c=c+(b[i+1:])
elif l1>l2:
for i in range(l2):
c.append(a[i])
c.append(b[i])
c=c+(a[i+1:])
return c

24、有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
for i in range(1,5):
for j in range(1,5):
for k in range(1,5):
if i!=k and i!=j and j!=k:
print(i,j,k)

25、一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
def jianban(n):
n=n/2
return n

a=eval(input("请输入高度："))
b=eval(input("请输入落地次数："))
c=a
d=a
e=a
#反弹高度
for i in range(b):
a=jianban(a)
#路程
if b==1:
c=a
elif b==2:
c=2*c
elif b>2:
for j in range(0,b-2,1):
c=c+jianban(d)
d=jianban(d)
c=c+e
print("经过",c,"米","第",b,"次反弹",a,"米",sep="")
26、最大公约数和最小公倍数的计算。从键盘接收两个整数，编写程序求出这两个整数的最大公约数和最小公倍数（两个数的乘积等于这两个数的最大公约数与最小公倍数的积。即(a,b)×[a,b]=a×b）
#求最大公约数
a=eval(input())
b=eval(input())
c=min(a,b)
ys=[]
k=0
for i in range(2,c+1):
if(a/i)%1==0 and (b/i)%1==0:
ys.append(i)
k=1
if k==0:
maxyueshu=1
else:
maxyueshu=max(ys)
print(maxyueshu)
#求最小公倍数
minbeishu=(a*b)/maxyueshu
print("%d"%minbeishu)

27、将1，2，…，9共9个数分成三组，分别组成三个三位数，且使这三个三位数构成1：2：3的比例，试求出所有满足条件的三个三位数。 例如：三个三位数192，384，576满足以上条件。
for i in range(100,1000):
a=2*i
b=3*i
if 100<a<1000 and 100<b<1000:
print(i,a,b,sep=' ')

28、若一个数（首位不为零）从左向右读与从右向左读都一样，我们就将其称之为回文数。
例如：给定一个10进制数56，将56加56（即把56从右向左读），得到121是一个回文数。
又如：对于10进制数87：
STEP1：87+78 = 165 STEP2：165+561 = 726
STEP3：726+627 = 1353 STEP4：1353+3531 = 4884
在这里的一步是指进行了一次N进制的加法，上例最少用了4步得到回文数4884。
def ishui(n):
n=str(n)
if n==n[::-1]:
return True
else:
return False
def ni(n):
n=str(n)
n=n[::-1]
n=eval(n)
return n

N=eval(input())
if 2<=N<=10:
N=N
else:
N=16
M=eval(input())
if N!=10:
M=str(M)
M=int(M,N) #将一个任意进制的数转化为十进制数
M=int(M)
cn=0
while not ishui(M):
M=M+ni(M)
cn+=1
if cn<=30:
print("STEP","=",cn,sep='',end='')
else:
print("Impossible!")
29、判断字符串中各元素的类型
a=b=c=0
n=input()
for char in n:
if char=='\n':#换行符
break
elif '0'<=char<='9':
a+=1
elif 'a'<=char<='z':
b+=1
elif 'A'<=char<='Z':
c+=1
print("有数字",a,"个,","有大写字母",c,"个,","有小写字母",b,"个",sep='')

30、编写函数：number是一个整数，若该数比指定宽度长则显示原数字符串，否则在前面补0以匹配指定宽度。
def tiaokuandu(n,width=5):
n=str(n)
w=len(n)
if w==width:
return n
else:
n=n[::-1]
n1='0'*(width-w)
n=n+n1
n=n[::-1]
return n
31、编写程序，生成一个包含20个随机整数的列表，然后对其中偶数下标的元素进行降序排列，奇数下标的元素不变。（提示：使用切片。）
import random
l=[]
for i in range(20):
a=random.randint(1,100)
l.append(a)
print(l)
l[::2]=sorted(l[::2],reverse=True) #True是降序
print(l)