Python经典编程30例

Python经典编程30例

所有代码均在python3.7环境下调试通过，为了防止排版原因导致不能正常运行，提供了正常运行情况下的代码截图。

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

def sushu(x):

i=0

for i in range(2,x):

if x % i ==0:

return False

break

if i+1==x:

return True

return False

n=int(input("请输入n:"))

for j in range(2,n):

if sushu(j)==True:

print(j,"是素数")

2、编写程序，生成一个包括100个随机整数的列表，然后从后向前删除所有素数

import random

def sushu(x):

i=0

for i in range(2,x):

if x % i ==0:

return False

break

if i+1==x:

return True

return False

s=[]

i=0

for i in range(0,30):

(t(1,10000))

for i in range(0,30):

print(s[i]," ",end='')

if i % 10 ==0:

print("n")

print("n")

print("T列表")

t=[]

for j in range(29,0,-1):

if sushu(s[j])==False:

(s[j])

for i in range(0,len(t)-1):

print(t[i]," ",end='')

if i % 10 ==0:

print("n")

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

n = int(input("请输入待分解的整数n=?"))

x = 1

flag = True

if 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")

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

def isprime(x):

if x==2: return True

if x%2==0: return False

n=3

while n*n<=x:

if x%n==0: return False

n+=2

return True

def gedb(x):

if x<4 or x%2!=0:

print("输入的数据不正确，应该是大于或等于4的偶数")

return

if x==4:

print('4=2+2')

return

for n in range(3,x,2):

if isprime(n) and isprime(x-n):

print(x,'=',n,'+',x-n)

return

def main():

x=int(input("输入大于或等于4的偶数"))

gedb(x)

main()

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

def isprime(x):

if x==2: return True

if x%2==0: return False

n=3

while n*n<=x:

if x%n==0: return False

n+=2

return True

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()

6、编写程序，求所有水仙花数。水仙花数是指一个三位数，其个位、十位、百位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+=1

print(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+k*k*k+l*l*l+m*m*m:

t+=1

print(i)

if t==0:

print("No such number")

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

解法一：

import random

list_1=[]

#生成随机整数列表

for i in range(20):

list_(t(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_t

print('排序后列表为:',list_1)

解法2：

import random

()

lst=[t(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],lst[j+2]=lst[j+2],lst[j]

bubble_sort(lst)

print(lst)

8、编写程序，输入行数，输出一个如下图所示的由“*”构成的等腰三角形(提示：用setw()函数)。

for i in range(6):

for k in range(5-i):

print(" ",end=" ")

for j in range(2*i+1):

print("*", end=" ")

print()

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

解法一

设总共捕了x条鱼，每个人看到的鱼共有Xn条， 则：

X1=x

X2=(X1-1)/5*4

X3=(X2-1)/5*4

X4=(X3-1)/5*4

X5=(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 0

x = 6

while True:

x += 5

if fish(5, x) == 1:

print(x)

break

for 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 = 0

while 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:

break

print("总共捕了",fish[0],"条鱼")

for i in range(0, 5):

print("第{0}人看到{1}条鱼".format(i+1, fish[i]))

10、编写程序，计算斐波拉契数列的后项与前项的比：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))

11、编写程序，计算卢卡斯数列的后项与前项的比：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))

12、编写函数，用于判断输入的字符串是否由字母和数字构成，并统计字符个数。

解法一

import string

def chartype(ch):

"""字符类型判断"""

if ch in _letters: return 'ascii_letters'

elif ch in : return 'digits'

elif ch in pace: return 'whitespace'

else: return 'other'

def chtypecount(s):

"""字符串类型计数器"""

counter = {}

for ct in map(chartype, s):

ault(ct, 0)

counter[ct] += 1

return counter

for chtype, cnts in chtypecount(input("Enter a string: ")).items():

print (chtype, cnts)

解法二

sum_d=0

sum_alpha=0

sum_other=0

sum_chinese=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+=1

elif 'u4e00' <= s[i] <= 'u9fff':

sum_chinese+=1

else:

sum_other+=1

print("数字：",sum_d,"个")

print("字母:",sum_alpha,"个")

print("其他符号:",sum_other,"个")

print("汉字：",sum_chinese,"个")

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

str = input("请您输入一串字符串：")

str1 = () # 去掉字符串前后空格

index = 0

count = 0

while 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 += 1

print("输入的字符串中一共有count = %d个单词" % count)

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

c=input("请输入字符");

A=""

B=""

for a in c[::2]:

A=A+a

for b in c[1:len(c):2]:

B=B+b

n=A+B

print(n)

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

#a = "aAsmr3idd4bgs7Dlsf9eAF"

a=input("请输入字符串：")

def fun1_2(x): #1&2

# x = () #大小写转换

num = []

dic = {}

for i in x:

if t(): #判断如果为数字，请将a字符串的数字取出，并输出一个新的字符串

(i)

else: #2 请统计a字符串出现每个字母的出现次数（忽视大小写），并输出一个字典。例：{'a':3,'b':1}

if i in dic:

continue

else:

dic[i] = (i)

new = ''.join(num)

print ("the new numbers string is: " + new)

print ("the dictionary is: %s" % dic)

fun1_2(a)

def fun3(x):

x = ()

new3 = []

for i in x:

if i in new3:

continue

else:

(i)

print (''.join(new3))

fun3(a)

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

解法一

str1 = "tomorrow is a good day tomorrow is a bad day tomorrow is a sunny day"

list1 = (" ")

dict1 ={}

for element in list1:

if element not in dict1:

dict1[element] = 1

else:

dict1[element] += 1

print(dict1)

解法二

str1 = "tomorrow is a good day tomorrow is a bad day tomorrow is a sunny day"

list1 = (" ")

dict1 ={}

for element in list1:

value = (element) #如果不存在则返回None

if value == None:

dict1[element] = 1

else:

dict1[element] += 1

print(dict1)

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

arr=[]

r=""

m=input("请输入")

for string in m:

(string)

last=arr[-1]

(0,last)

()

for str in arr:

r=r+str

print(r)

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

#输入一串字符，将大写字母转换成小写字母，小写字母转换为大写字母

def LtoU():

a = input("请 输入字符：")

b = []

for n in a :

if "a"<= n <= "z":

(())

elif"A" <= n <= "Z" :

(())

else:

(n)

print("".join(b))

def aToA():

a = input("请 输入字符：")

b = []

for n in a :

if n == "a":

(())

else:

(n)

print("".join(b))

aToA()

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

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

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

l = []

s = "hello world hello python"

for i in (" "):

if i not in l:

(i)

result = " ".join(l)

print(result)

print()

def onlyOne(x):

m=[]

print(x)

for j in (" "):

if j not in m:

(j)

result =" ".join(m)

return result

t=input("请输入一个英文句子：")

print(onlyOne(t))

21、编写程序，输入一段英文，输出英文中所有长度为3个字母的单词。

import re

x = input('Please input a string:')

pattern = e(r'b[a-zA-Z]{3}b')

print(l(x))

22、编写程序，输入一段英文，输出字符数最多的单词。

import re

words=input("Input the words:")

l=('[. ]+',words) #使用空格分隔词语，得到各个单词

print(l)

i=0 #这里我设置的是计数器

s=""

for i in l:

if len(i)>len(s): #如果单词的长度为3 输出

s=i

else:

print('')

print(s)

23、编写程序，要求输入一段英文，以及此段中的一个单词和另外一个单词，然后显示

用第二个单词替换第一个单词后的句子。

str='The weather today is really good.'

fword=input('请输入要查找的单词')

rword=input('请输入要替换的单词')

c=(fword)

if c>0:

str=e(fword,rword)

print('替换后的句子为：',str)

else:

print('句子中没有要查找的单词')

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

def myfun():

s=[]

for i in range(0,3):

t=int(input("请输入一个数："))

(t)

print(max(s))

print(s)

myfun()

25、编写函数，模仿内置函数sort()

s=[1,-3,2,6,8,11,-5,28,88]

t=[]

def mysort(x):

for i in range(0,len(x)):

(min(x))

(min(x))

return t

print(mysort(s))

26、编写函数，求出11111之和，函数形参为n，n由用户...1!2!3!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))

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

a = input("请输入一个数:")

if t():

a = str(a)

for i in range(len(a)):

if a[i] == a[len(a)-i-1]:

print(a,"是回文数")

else:

print(a,"不是回文数")

break

else:

print("请输入自然数:")

28、编写程序，运用递归方法分别求出斐波拉契数列和卢卡斯数列前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))

29、编写程序，运用递归方法求a+aa+aaa+......+aa...a(n个a)之和，a、n由用户在主函数中输入。

from functools import reduce

a = int(input('a:'))

n = int(input(('n:')))

list = []

for i in range(1,n+1):

(int('{}'.format(a)*i))

s = reduce(lambda x,y:x+y,list)

print(list)

print(s)

30、用牛顿迭代法求方程f(x)程根的迭代公式为

xn1xex在区间[0,1]中的根。牛顿迭代法解非线性方f(x)xn'n,f’(x)是f(x)的导函数，结束条件为f(xn)|xn1xn|106

def f(xi):

return xi-2.718**(-xi)

def f1(xi):

return 1+2.718**(-xi)

x=[]

(0.5)

eps=1e-6 #误差限制

error=abs(f(x[-1])) #最新加的x在最后

number_iteration=0

while error>eps:

(x[-1]-f(x[-1])/f1(x[-1])) #x k+1

error=abs(f(x[-1]))

number_iteration=number_iteration+1

print('牛顿法迭代次数为%f次'%(number_iteration)) #格式化输出

print('方程的根x*为%f'%(x[-1]))

print('f(x*)的值为%f'%(f(x[-1])))

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

import time

start=()

s=1

for i in range(1,201):

s*=i

print(s)

print("累乘用时:",()-start)

def jiechen(x):

if x==0 or x==1:

return 1

else:

return x*jiechen(x-1)

start=()

t=jiechen(200)

print(t)

print("递归用时:",()-start)