Python常见习题

##第三章：选择与循环

1、编写程序，生成一个包含50个随机整数的列表，然后删除其中所有的奇数（提示：从后往前删）

import random
list=[]
for i in range(50):
    list.append(random.randint(0,1000))
print(list,len(list))
for j in range(len(list))[::-1]:
    if list[j] %2!=0:
        del list[j]
print(list)

2、 编写一个程序，生成一个包含20个随机整数的列表，然后对其中偶数下标的元素进行降序排列，奇数下标的元素不变（使用切片）

import random
list=[]
for i in range(20):
    list.append(random.randint(0,100))
print(list)
list1=sorted(list[::2],reverse=True)
k=0
for j in range(0,20,2):
    list[j]=list1[k]
    k+=1
print(list)

3、编写程序，用户从键盘输入小于1000的整数，对其进行因式分解。例如，10=2x5，60=2x2x3x5

num=input('输入小于1000的整数：')
num=int(num)
if num==1:
    print('1=1x1',end=' ')
else:
    for i in range(1,num):
        if num % i==0:
            print(num,'=',i,'x',int(num/i),end=' ')

4、编写程序，至少使用两种不同的方法计算100以内所有奇数的和

print(sum(list(range(100))[1::2]))
i=1
sum=0
while i<=100:
    if i % 2==1:
        sum+=i
    i+=1
print(sum)

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

list=[1,2,3,4]
for i in list:
    for j in list:
        if i!=j:
            for k in list:
                if i!=k and j!=k:
                    for l in list:
                        if i!=l and j!=l and k!=l:
                            print(i*1000+j*100+k*10+l)

6、编写程序，实现分段函数计算

def y(x):
    if x<0:
        return 0
    elif 0<=x<5:
        return x
    elif 5<=x<10:
        return 3*x-5
    elif 10<=x<=20:
        return 0.5*x-2
    else:
        return 0
num=input('请输入参数x:')
print(y(int(num)))

第四章：字符串与正则表达式

1、编写函数实现字符串加密和解密，循环使用指定密匙，采用简单的异或方法。

def crypt(source,key):
    from itertools import cycle
    result=''
    temp=cycle(key)
    for ch in source:
        result=result+chr(ord(ch) ^ ord(next(temp)))   #^在算术运算中，表示将数字化为二进制异或。
    return result

source='ShanDong Institute of Business and Technology'
key='Dong Fuguo'

print('Before Encrypted:'+source)
encrypted=crypt(source,key)
print('After Encrypted:'+encrypted)
decrypted=crypt(encrypted,key)
print('After Decrypted:'+decrypted)

##第五章：函数设计与使用

1、编写函数计算圆的面积

from math import pi as PI

def CircleArea(r):
    if isinstance(r,int) or isinstance(r,float):
        return PI*r*r
    else:
        return ('You must give me an integer or float as radius.')

print(CircleArea(12))

2、编写函数，接收任意多个实数，返回一个元组，其中第一个元素为所有参数的平均值，其他元素为所有参数中大于平均值的实数。

def demo(*para):
    avg=sum(para)/len(para) #注意Python2.x与Python3.x对除法运算符"/"的解释不同
    g=[i for i in para if i>avg]
    return (avg,)+tuple(g)

print(demo(1,2,3,4))

3、编写函数，接收字符串参数，返回一个元组，其中第一个元素为大写字母个数，第二个元素为小写字母个数。

def demo(s):
    result=[0,0]
    for ch in s:
        if 'a'<=ch<='z':
            result[1]+=1
        elif 'A'<=ch<='Z':
            result[0]+=1
    return tuple(result)

print(demo('aaaabbbbC'))

4、编写函数，接收包含20个整数的列表lst和一个整数k作为参数，返回新列表。处理规则为：将列表lst中下标k之前的元素逆序，下标k之后的元素逆序，然后将整个列表lst中的所有元素逆序。

def demo(lst,k):
    x=lst[:k]
    x.reverse()		#将列表lst中下标k之前的元素逆序
    print(x)
    y=lst[k:]
    y.reverse()		#将列表lst中下标k之后的元素逆序
    print(y)
    r=x+y
    r.reverse()		#将整个列表中的所有元素逆序
    return r

lst=list(range(1,21))
print(lst)
print(demo(lst,5))

5、 编写函数，接收整数参数 t，返回斐波那契数列中大于 t 的第一个数。

def demo(t):
    a,b=1,1
    while b<t:
        a,b=b,a+b
    else:
        return b

print(demo(50))

*6、编写函数，接收一个包含若干整数的列表参数lst，返回一个元组，其中第一个元素为列表lst中的最小值，其余元素为最小值在列表lst中的下标。

import random

def demo(lst):
    m=min(lst)
    result=(m,)
    for index,value in enumerate(lst):
        if value==m:
            result=result+(index,)
    return result

x=[random.randint(1,20) for i in range(50)]
print(x)
print(demo(x))

*7、编写函数，接收一个整数t为参数，打印杨辉三角的前t行。

def demo(t):
    print([1])
    print([1,1])
    line=[1,1]
    for i in range(2,t):
        r=[]
        for j in range(0,len(line)-1):
            r.append(line[j]+line[j+1])
        line=[1]+r+[1]
        print(line)

demo(10)

*8、编写函数，接收一个正偶数为参数，输出两个素数，并且这两个素数之和等于原来的正偶数。如果存在多组符合条件的素数，则全部输出。

import math

def IsPrime(n):
    m=int(math.sqrt(n))+1
    for i in range(2,m):
        if n%i==0:
            return False
    return True

def demo(n):
    if isinstance(n,int) and n>0 and n%2==0:
        for i in range(3,int(n/2)+1):
            if i%2==1 and IsPrime(i) and IsPrime(n-i):
                print(i,'+',n-i,'=',n)

demo(60)

9、编写函数，接收两个正整数作为参数，返回一个数组，其中第一个元素为最大公约数，第二个元素为最小公倍数。

def demo(m,n):
    if m>n:
        m,n=n,m
    p=m*n
    while m!=0:		#辗转相除法求最大公约数
        r=n%m
        n=m
        m=r
    return (int(p/n),n)		#乘积除以最大公约数为最小公倍数

print(demo(20,30))

*10、编写函数，接收一个所有元素值互不相等的整数列表x和一个整数n，要求将值为n的元素作为支点，将列表中所有值小于n的元素全部放到n的前面，所有值大于n的元素放到n的后面。（模拟第一次快排的结果）

import random

def demo(list,n):
    if n not in list:
        print(n,'is not an element of',list)
        return

    i=list.index(n)		#获取指定元素在列表中的索引
    list[0],list[i]=list[i],list[0]		#将指定元素与第0个元素交换
    key=list[0]

    i=0
    j=len(list)-1
    while i<j:
        while i<j and list[j]>=key:		#从后向前寻找第一个比指定元素小的元素
            j-=1
        list[i]=list[j]

        while i<j and list[i]<=key:		#从前向后寻找第一个比指定元素大的元素
            i+=1
        list[j]=list[i]
        list[i]=key

list=list(range(1,10))
random.shuffle(list)
print(list)
demo(list,4)
print(list)

*11、编写函数，计算字符串匹配的准确率

​ 以打字练习程序为例，假设origin为原始内容，userInput为用户输入的内容，下面的代码用来测试用户输入的准确率。

#假设以origin为原始内容，userInput为用户输入的内容
def Rate(origin,userInput):
    if not (isinstance(origin,str) and isinstance(userInput,str)):
        print('The two parameters must be strings.')
        return
    if len(origin)<len(userInput):
        print('Sorry,I suppose the second parameter string is shorter.')
        return
    right=0
    for origin_char,user_char in zip(origin,userInput):
        if origin_char==user_char:
            right +=1
    return right/len(origin)

origin='Shangdong'
userInput='Shangdong'
print(Rate(origin,userInput))