Python_自测100题

参考：
Python自测100题（上）
Python自测100题（下）

1.题目：有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？ 程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。

res = []
for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            if (i!=j) and (i!=k) and (j!=k):
                res.append(i*100+j*10+k)
print(res)

2.题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？
程序分析：用字典表示各段的提成，根据题意暴力计算即可；注意 if 语句中的判断变量类型。

DIC = {'down_10':0.1,'10_20':0.075,'20_40':0.05,'40_60':0.03,'60_100':0.015,'up_100':0.01}
your_money = 0
I = input('please input your I (以万为单位) : ')
I = int(I)
if I < 0:
    print('input error!!!')
elif I <= 10:
    your_money = I * DIC['down_10']
elif I <= 20:
    your_money = 10 * DIC['down_10'] + (I-10) * DIC['10_20']
elif I <= 40:
    your_money = 10 * DIC['down_10'] + 10* DIC['10_20'] + (I-20) * DIC['20_40']
elif I <= 60:
    your_money = 10 * DIC['down_10'] + 10 * DIC['10_20'] + 20 * DIC['20_40'] + (I-40) * DIC['40_60']
elif I <= 100:
    your_money = 10 * DIC['down_10'] + 10 * DIC['10_20'] + 20 * DIC['20_40'] + 20 * DIC['40_60'] + (I-60) * DIC['60_100']
else:
    your_money = 10 * DIC['down_10'] + 10 * DIC['10_20'] + 20 * DIC['20_40'] + 20 * DIC['40_60'] + 40 * DIC['60_100'] + (I-100) * DIC['up_100']

print('your_money is :' + str(your_money) + 'w')

3.题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
程序分析： 用while语句，找到这个数时跳出while循环，调用math模块中的sqrt()函数,开方后取整，判断取整后的数再平方是否等于原数。整数包括正整数负整数0，所以要从-100开始循环，小于-100后加上100不可能是一个完全平方数。
这种暴力解法无法很好的确定循环的次数，另附上参考中较标准的解法：

import math
i = -100
while i<100000:
    if (int(math.sqrt(i+100)))*(int(math.sqrt(i+100))) == (i+100):
        if (int(math.sqrt(i+268)))*(int(math.sqrt(i+268))) == (i+268):
            print(i)
        else:
            i+=1
            continue
    i += 1

4.题目：输入某年某月某日，判断这一天是这一年的第几天？
程序分析：先把正常年份前n个月的天数存储在字典，分割输入的字符串，强制转换为长整型，判断是否为闰年，然后如果是闰年的话二月份以后的天数要多加一天，不是闰年的话，如果输入是a月b号，则算出前a-1月的天数，加上b即可。
闰年判断：

sum = [0,0,0,0,0,0,0,0,0,0,0,0]
sum[0]=31
sum[1]=28+sum[0]
sum[2]=31+sum[1]
sum[3]=30+sum[2]
sum[4]=31+sum[3]
sum[5]=30+sum[4]
sum[6]=31+sum[5]
sum[7]=31+sum[6]
sum[8]=30+sum[7]
sum[9]=31+sum[8]
sum[10]=30+sum[9]
sum[11]=31+sum[10]
print(sum)
data = input('please input data(example:20200101) : ')
data_year = int(data[0:4])
data_month = int(data[4:6])
data_day = int(data[6:])
res = 0
if data_year%4 == 0:
    if data_year%100 != 0 or data_year%400 ==0:
        if data_month > 2:
            res = sum[data_month-2] + data_day +1
        else:
            res = sum[data_month-2] + data_day
    else:
        res = sum[data_month-2] + data_day
else:
    res = sum[data_month-2] + data_day
print(res)

5.题目：输入三个整数x,y,z，请把这三个数由小到大输出。
程序分析:用sort()排序函数即可

print('please input three numbers :')
res = []
for i in range(3):
    res.append(int(input()))
res.sort()
print(res)

6.题目：斐波那契数列。
程序分析：斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……。前两数之和等于后面一个数。

a = 0
b = 1
while a<1000:
    print(a)
    a,b = b,a+b

7.题目：将一个列表的数据复制到另一个列表中。
程序分析：使用[:]

list1 = [1,2,3,4,5,6,7]
list_copy = list1[:]
print(list_copy)

8.题目：输出 9*9 乘法口诀表。
程序分析：i，j循环

for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='   ')
        #print("%d*%d=%d" % (j, i, i * j), end=" ")
    print('\n')

9.题目：暂停一秒输出。
程序分析：time模块sleep函数（对应C中delay延迟）

import time
print('start')
time.sleep(1)
print('end')

10.题目：暂停一秒输出，并格式化当前时间。
程序分析：利用time模块，先获取时间戳：time.time()，再获得当地时间：time.localtime()，然后格式化时间time.asctime()。

import time
print ("start:", time.asctime( time.localtime(time.time()) ))
time.sleep(1)
print ("end:", time.asctime( time.localtime(time.time()) ))

11.题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
程序分析：兔子的规律为数列1,1,2,3,5,8,13,21…（最后乘以2）

a=1
b=1
for i in range(1,101):
    a,b = b,a+b
    print('第',i,'个月的兔子数为：',a*2)

12.题目：判断101-200之间有多少个素数，并输出所有素数。
程序分析：素数即质数，是指在大于1的自然数中，除了1和它自身外，不能被其他自然数整除的数。

import math
res = 0
res_list = []
for i in range(101,201):
    flag = 0
    for j in range(2,int(math.sqrt(i))+1):
        if i%j == 0:
            flag = 1
    if flag==0:
        res += 1
        res_list.append(i)
print('素数个数为：',res)
print('素数为：',res_list)

13.题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
（也可以用字符串分片来算）

for i in range(100,1000):
    temp = 0
    temp = (i//100)**3 + ((i-(i//100)*100)//10)**3 + (i-(i//100)*100-((i-(i//100)*100)//10)*10)**3
    if temp==i:
        print(i)

14.题目：将一个正整数分解质因数。例如：输入90,打印出90=2x3x3x5。
程序分析：（1）先定义判断质数的函数；（2）判断输入数字n是否为质数，若为质数则直接打印出来；（3）如果不为质数，进入循环，找这个数的因子i，判断因子是否为质数，若为质数则打印这个因子，n变为n/i，i=2，不为质数的话i=i+1，再次循环，注意判断最后一个质数后不用打印“×”。

import math
def sushu(i):
    flag = 0
    for j in range(2,int(math.sqrt(i))+1):
        if i%j == 0:
            flag = 1
    return flag

n = int(input('please input a number:'))
i = 2
temp1 = 1
temp2 = n
print(n,'=',end='')
if sushu(n) == 0:
    print(n)
else:
    while True:
        if n%i  == 0:
            if sushu(i) == 0 :
                temp1 *= i
                if temp1 != temp2:
                    print(i,'×',end='')
                else:
                    print(i)
                    break
                n = n / i
                i=2
            else:
                i+=1
        else:
            i+=1

15.题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
程序分析：if，elif即可

grade = int(input('please input a grade(0-100):'))
if grade>100 or grade<0:
    print('input error')
else:
    if grade >= 90:
        print('A')
    elif grade>=60:
        print('B')
    else:
        print('C')

16.题目：输出指定格式的日期。
程序分析：使用 time 模块;或者 datetime模块，具体见菜鸟教程时间模块介绍。

import time

# 格式化成2016-03-20 11:45:39形式
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

# 格式化成Sat Mar 28 22:24:24 2016形式
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))

# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))

import datetime

miyazakiBirthDate = datetime.date(1941, 1, 5)
print(miyazakiBirthDate.strftime('%d/%m/%Y'))

17.题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
程序分析：转换成ASCII码，遍历字符串，判断语句各字符的类型

sentences = input('请输入一行字符：')
DIC = {'字母':0,'空格':0,'数字':0,'其他':0}
for sentence in sentences:
    if (ord(sentence) >=97 and ord(sentence) <=122) or (ord(sentence) >=65 and ord(sentence) <=90) :
        DIC['字母'] += 1
    elif (ord(sentence) >=48 and ord(sentence) <=57):
        DIC['数字'] += 1
    elif ord(sentence) == 32:
        DIC['空格'] += 1
    else:
        DIC['其他'] += 1
print (DIC)

18.题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
程序分析：计算每次相加的值

a = int(input('请输入一个数字：'))
n = int(input('请输入要相加的次数：'))
sum = 0
temp = 0
for i in range(n):
    temp += a * (10**i)
    sum += temp
print(sum)

19.题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。
程序分析：先找出一个数的因子，再计算是否等于因子之和。注意第二个循环里"+2"是为了把1考虑进去。

for i in range(1,1000):
    temp = 0
    for j in range(1,(i//2)+2):
        if i%j == 0:
            temp += j
    if i == temp:
        print(i,end=' ')

20.题目：一球从100米高度*落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
程序分析：每次求和即可。

n = 100
temp = 100
res = 0
for i in range(0,10):
    res += temp
    temp /= 2
print(res,temp)

20.题目：一球从100米高度*落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
程序分析：每次求和即可，注意题目是第十次落地，不加弹起的高度。

n = 100
temp = 100
res = 0
for i in range(0,10):
    res += temp
    temp /= 2
    res += temp
print(res-temp,temp)

21.题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
程序分析：逆向思维，从后往前推,列出方程式，注意第十次循环算出的是前一天的桃子数。

temp = 1
sum = 0
for i in range(10):
    sum = temp
    temp = (temp+1)*2

print(sum)

22.题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
程序分析：考察具体问题转换为编程的能力。遍历一个存有[‘x’,‘y’,‘z’]的列表，最后用”a说他不和x比，c说他不和x,z比“来判断输出。

L = ['x','y','z']
for a in L:
    for b in L:
        if a != b:
            for c in L:
                if c != a and c != b:
                    if a != 'x' and c != 'x' and c != 'z':
                        print('a','and',a,' b','and',b,' c','and',c)

23.题目：打印出如下图案（菱形）:
程序分析：可以把这个图像的像素看成7x7，利用格式化函数format()绘制。

   *
  ***
 *****
*******
 *****
  ***
   *

print("{0}{1}{2}{3}{4}{5}{6}".format(" ", " ", " ", "*", " ", " ", " "))  # 设置指定位置
print("{0}{1}{2}{3}{4}{5}{6}".format(" ", " ", "*", "*", "*", " ", " "))
print("{0}{1}{2}{3}{4}{5}{6}".format(" ", "*", "*", "*", "*", "*", " "))
print("{0}{1}{2}{3}{4}{5}{6}".format("*", "*", "*", "*", "*", "*", "*"))
print("{0}{1}{2}{3}{4}{5}{6}".format(" ", "*", "*", "*", "*", "*", " "))
print("{0}{1}{2}{3}{4}{5}{6}".format(" ", " ", "*", "*", "*", " ", " "))
print("{0}{1}{2}{3}{4}{5}{6}".format(" ", " ", " ", "*", " ", " ", " "))

24.题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。
程序分析：注意前后分子分母的关系，循环20次即可。

fenzi = 2
fenmu = 1
sum = 0
for i in range(20):
    sum += fenzi/fenmu
    fenmu,fenzi = fenzi,fenmu+fenzi
print(sum)

25.题目：求1+2!+3!+…+20!的和。
程序分析:遍历求和即可。

sum = 0
temp = 1
for i in range(1,21):
    temp *= i
    sum += temp
print(sum)

26.题目：利用递归方法求5!。
程序分析：递归即可,注意递归跟循环的区别，递归是多次调用一个函数。

def fn(n):
    if n==0:
        sum = 1
    else:
        sum = n*fn(n-1)
    return sum
print(fn(5))

27.题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
程序分析：确定何时跳出递归，注意这里是字符串，无法更改，所以找一个中间变量temp来存储字符串。

def F(str):
    n = len(str)
    if n==0:
        pass
    else:
        print(str[n-1],end='')
        temp = str[0:n-1]
        F(temp)

str = input('请输入字符串：')
F(str)

28.题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
程序分析：逆向求解,用递归思想。要注意只打印最后的20，需要把打印函数放在person_num==0，那个判断条件下。

def F(person_age,person_num):
    if person_num == 0:
        print(person_age)
        pass
    else:
        person_age += 2
        F(person_age,person_num-1)

F(10,5)

29.题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
程序分析：字符串索引，从后往前打印即可。

n = input('请输入一个不多于5位的正整数：')
print('输入数字为：',len(n),'位数')
for i in range(len(n)):
    print(n[len(n)-i-1],end='')

30.题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
程序分析：运用字符串索引判断。

n = input('请输入一个5位数：')
flag = False
for i in range(int(len(n)/2)):
    if n[len(n)-i-1]==n[i]:
        flag = True
    else:
        flag = False
if flag:
    print('yes')
else:
    print('no')

31.题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。
程序分析：输入后判断即可。

first = input()
if first == 'M':
    print("星期一")
elif first == 'W':
    print("星期三")
elif first == 'F':
    print("星期五")
elif first == 'T':
    second = input('请输入第二个字母:')
    if second == 'u':
        print("星期二")
    else:
        print("星期四")
elif first == 'S':
    second = input('请输入第二个字母:')
    if second == 'u':
        print("星期日")
    else:
        print("星期六")
else:
    print("请重新输入")

32.题目：按相反的顺序输出列表的值。
程序分析：运用[::-1]反向复制列表。

l = [1,2,3,4,5,6,7]
l_new = l[::-1]
for i in l_new:
    print(i,end = ' ')

33.题目：按逗号分隔列表
程序分析：同32题

l = [1,2,3,4,5,6,7]
l_new = l[::-1]
for i in l_new:
    print(i,end = ',')

34.题目：练习函数调用。
程序分析：略

def f():
    print('xxx')
f()

35.题目：文本颜色设置。
程序分析：程序分析：菜鸟教程 https://www.runoob.com/python/python-exercise-example35.html

class bcolors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'
print(bcolors.OKBLUE + "警告的颜色字体?" + bcolors.ENDC)

36.题目：求100之内的素数。
程序分析：程序分析：素数即质数，是指在大于1的自然数中，除了1和它自身外，不能被其他自然数整除的数。

import math
res = 0
res_list = []
for i in range(1,101):
    flag = 0
    for j in range(2,int(math.sqrt(i))+1):
        if i%j == 0:
            flag = 1
    if flag==0:
        res += 1
        res_list.append(i)
print('素数个数为：',res)
print('素数为：',res_list)

37.题目：对10个数进行排序。
程序分析：用python所带的min(),index()函数。

l = [2,3,5,7,9,1,0,4,6,8]
l_new = []
for i in range(len(l)):
    temp = l.index(min(l))
    l_new.append(min(l))
    del l[temp]

print(l_new)

38.题目：求一个3*3矩阵主对角线元素之和。
程序分析：利用双重for循环控制输入二维数组，再将a[i][j]累加后输出。

l = [[1,2,3],[5,3,9],[3,6,8]]
sum = 0
for i in range(3):
    for j in range(3):
        if j==i:
            sum += l[i][j]
print(sum)

39.题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
程序分析：先利用选择排序，排列数组，然后利用判断语句列出多种情况，得出要插入数组位置的索引，运用list.insert(index, obj)， list.append(obj)函数。

l = [2,3,5,7,9,1,0,4,6,8]
lenth = len(l)
for i in range(lenth):
    min = l[i]
    s = i
    for j in range(i,lenth):
        if l[j]<min:
            min = l[j]
            s = j
    l[i],l[s] = l[s],l[i]
print(l)

n = int(input('请输入需要插入数组的数字：'))
for i in range(lenth):
    if i == 0:
        if n == l[i] or n<l[i] :
            l.insert(i,n)
            break
    else:
        if n == l[i] or (n<l[i] and n>l[i-1]):
            l.insert(i,n)
            break
        elif n>l[i]:
            l.append(n)
            break
print(l)

40.题目：将一个数组逆序输出。
程序分析：（1）利用数组内置函数list.reverse()；（2）头尾元素互换。

l = [2,3,5,7,9,1,0,4,6,8]
l.reverse()
print(l)

l = [2,3,5,7,9,1,0,4,6,8]
lenth = len(l)
for i in range(int(lenth/2)):
    l[i],l[lenth-1-i] = l[lenth-1-i],l[i]
print(l)

41.题目：模仿静态变量的用法。
程序分析：菜鸟教程 https://www.runoob.com/python/python-exercise-example41.html
注意静态变量是程序结束后释放。

def varfunc():
    var = 0
    print('var = %d' % var)
    var += 1
if __name__ == '__main__':
    for i in range(3):
        varfunc()

# 类的属性
# 作为类的一个属性吧
class Static:
    StaticVar = 0
    def varfunc(self):
        self.StaticVar += 1
        print(self.StaticVar)

a = Static()
print(a.StaticVar)
for i in range(3):
    a.varfunc()

42.题目：学习使用auto定义变量的用法。
程序分析：答案来自菜鸟教程。

num = 2
def autofunc():
    num = 1
    print('internal block num = %d' % num)
    num += 1
for i in range(3):
    print('The num = %d' % num)
    num += 1
    autofunc()

43.题目：模仿静态变量(static)另一案例。
程序分析：演示一个python作用域使用方法。类内外参数不同步。

class Num:
    nNum = 1
    def inc(self):
        self.nNum += 1
        print('nNum = %d' % self.nNum)

if __name__ == '__main__':
    nNum = 2
    inst = Num()
    for i in range(3):
        nNum += 1
        print('The num = %d' % nNum)
        inst.inc()

44.两个 3 行 3 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵。
程序分析：略。

X = [[12,7,3],[4,5,6],[7,8,9]]
Y = [[5,8,1],[6,7,3],[4,5,9]]
Z = [[0,0,0],[0,0,0],[0,0,0]]
for i in range(3):
    for j in range(3):
        Z[i][j] = X[i][j] + Y[i][j]
print(Z)

45.题目：统计 1 到 100 之和。
程序分析：循环遍历相加即可。

sum = 0
for i in range(1,101):
    sum += i
print(sum)

46.题目：求输入数字的平方，如果平方运算后小于 50 则退出。
程序分析：略。

n = int(input('请输入一个数字:'))
if n**2 < 50:
    pass
else:
    print(n**2)

47.题目：两个变量值互换。
程序分析：略。

a,b = 10,20
a,b = b,a
print(a,b)

48.题目：数字比较。
程序分析：略。

a = int(input())
b = int(input())
if a>b:
    print('%d 大于 %d'%(a,b))
elif a<b:
    print('%d 小于 %d'%(a,b))
else:
    print('%d 等于 %d'%(a,b))

49.题目：使用lambda来创建匿名函数。
程序分析:参考菜鸟教程，注意lambda后面跟着的是参数，冒号后是具体函数要实现的内容。

MAXIMUM = lambda x, y: (x > y) * x + (x < y) * y
MINIMUM = lambda x, y: (x > y) * y + (x < y) * x

if __name__ == '__main__':
    a = 10
    b = 20
    print('The largar one is %d' % MAXIMUM(a, b))
    print('The lower one is %d' % MINIMUM(a, b))

50.题目：输出一个随机数。
程序分析：使用 random 模块。

import random
print(random.randint(0, 9))#0-9整数
print(random.random())#0-1浮点数
print(random.uniform(1.1, 5.4))#1.1-5.4浮点数
print(random.choice('hadshalffhla'))#字符串中随机一个字符
print(random.randrange(1,100,2))#生成从 1 到 100 间隔为 2 的随机整数

51.题目：学习使用按位与 & 。
程序分析：0&0=0; 0&1=0; 1&0=0; 1&1=1。

print(0&0,0&1,1&0,1&1)

52.题目：学习使用按位或 | 。
程序分析：0|0=0; 0|1=1; 1|0=1; 1|1=1。

print(0|0,0|1,1|0,1|1)

53.题目：学习使用按位异或 ^ 。
程序分析：0^0=0; 0^1=1; 1^0=1; 1^1=0。

print(0^0,0^1,1^0,1^1)

54.题目：取一个整数a从右端开始的4〜7位。
程序分析：可以这样考虑： (1)先使a右移4位。 (2)设置一个低4位全为1,其余全为0的数。可用(0<<4) (3)将上面二者进行&运算。

a = int(input('请输入一个整数：'))
b = a>>4
c = ~(~0 << 4)
d = b&c
print(d)

55.题目：学习使用按位取反~。

a,b = 0,1
print(~a,~b)

56.题目：画图，学画圆形。
程序分析：turtle的使用。
turtle库详解
turtle画出的有意思的图

import turtle
pen = turtle.Turtle()
pen.circle(50)
print(pen)
turtle.mainloop()

57.题目：画图，学画直线。

import turtle
pen = turtle.Turtle()
pen.forward(300)
print(pen)
turtle.mainloop()

58.题目：画图，学画方形。

import turtle
pen = turtle.Turtle()
pen.forward(50)
#画笔右转90度
pen.right(90)
pen.forward(50)
pen.right(90)
pen.forward(50)
pen.right(90)
pen.forward(50)
print(pen)
turtle.mainloop()

59.题目：画图，综合例子。
程序分析：画一个实时时钟，用到turtle，datetime库。

import turtle
from datetime import *


# 抬起画笔，向前运动一段距离放下
def Skip(step):
    turtle.penup()
    turtle.forward(step)
    turtle.pendown()


def mkHand(name, length):
    # 注册Turtle形状，建立表针Turtle
    turtle.reset()
    Skip(-length * 0.1)
    # 开始记录多边形的顶点。当前的乌龟位置是多边形的第一个顶点。
    turtle.begin_poly()
    turtle.forward(length * 1.1)
    # 停止记录多边形的顶点。当前的乌龟位置是多边形的最后一个顶点。将与第一个顶点相连。
    turtle.end_poly()
    # 返回最后记录的多边形。
    handForm = turtle.get_poly()
    turtle.register_shape(name, handForm)


def Init():
    global secHand, minHand, hurHand, printer
    # 重置Turtle指向北
    turtle.mode("logo")
    # 建立三个表针Turtle并初始化
    mkHand("secHand", 135)
    mkHand("minHand", 125)
    mkHand("hurHand", 90)
    secHand = turtle.Turtle()
    secHand.shape("secHand")
    minHand = turtle.Turtle()
    minHand.shape("minHand")
    hurHand = turtle.Turtle()
    hurHand.shape("hurHand")

    for hand in secHand, minHand, hurHand:
        hand.shapesize(1, 1, 3)
        hand.speed(0)

    # 建立输出文字Turtle
    printer = turtle.Turtle()
    # 隐藏画笔的turtle形状
    printer.hideturtle()
    printer.penup()


def SetupClock(radius):
    # 建立表的外框
    turtle.reset()
    turtle.pensize(7)
    for i in range(60):
        Skip(radius)
        if i % 5 == 0:
            turtle.forward(20)
            Skip(-radius - 20)

            Skip(radius + 20)
            if i == 0:
                turtle.write(int(12), align="center", font=("Courier", 14, "bold"))
            elif i == 30:
                Skip(25)
                turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold"))
                Skip(-25)
            elif (i == 25 or i == 35):
                Skip(20)
                turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold"))
                Skip(-20)
            else:
                turtle.write(int(i / 5), align="center", font=("Courier", 14, "bold"))
            Skip(-radius - 20)
        else:
            turtle.dot(5)
            Skip(-radius)
        turtle.right(6)


def Week(t):
    week = ["星期一", "星期二", "星期三",
            "星期四", "星期五", "星期六", "星期日"]
    return week[t.weekday()]


def Date(t):
    y = t.year
    m = t.month
    d = t.day
    return "%s %d%d" % (y, m, d)


def Tick():
    # 绘制表针的动态显示
    t = datetime.today()
    second = t.second + t.microsecond * 0.000001
    minute = t.minute + second / 60.0
    hour = t.hour + minute / 60.0
    secHand.setheading(6 * second)
    minHand.setheading(6 * minute)
    hurHand.setheading(30 * hour)

    turtle.tracer(False)
    printer.forward(65)
    printer.write(Week(t), align="center",
                  font=("Courier", 14, "bold"))
    printer.back(130)
    printer.write(Date(t), align="center",
                  font=("Courier", 14, "bold"))
    printer.home()
    turtle.tracer(True)

    # 100ms后继续调用tick
    turtle.ontimer(Tick, 100)


def main():
    # 打开/关闭龟动画，并为更新图纸设置延迟。
    turtle.tracer(False)
    Init()
    SetupClock(160)
    turtle.tracer(True)
    Tick()
    turtle.mainloop()


if __name__ == "__main__":
    main()

60.题目：计算字符串长度。

a =input()
print(len(a))

61.题目：打印出杨辉三角形（要求打印出10行如下图）。
程序分析：画出三角形，找规律。

def YangHui(num = 10):
    LL = [[1]]
    print(LL[0])
    for i in range(1,num):
        temp3 = []
        for j in range(i+1):
            if j == 0:
                temp3.append(LL[i-1][j])
            elif j == i:
                temp3.append(LL[i-1][j-1])
            else:
                temp3.append(LL[i-1][j-1]+LL[i-1][j])
        LL.append(temp3)
        print(LL[i])
YangHui(num = 20)

#方法2来自百度，程序简洁但不易理解。
def YangHui (num = 10):
    LL = [[1]]
    print(LL[0])
    for i in range(1,num):
        LL.append([(0 if j== 0 else LL[i-1][j-1])+ (0 if j ==len(LL[i-1]) else LL[i-1][j]) for j in range(i+1)])
        print(LL[i])
    return LL
YangHui(num = 10)

62.题目：查找字符串。
程序分析：用find()函数，查找到的是字符串第一个字符的索引位置。

a = 'abcdefghi'
b = 'efg'
print(a.find(b))

63.题目：画椭圆

import turtle
pen=turtle.Turtle()
a=1
for i in range(120):
    if 0<=i<30 or 60<=i<90:
        a=a+0.2
        pen.lt(3)
        pen.fd(a)
    else:
        a=a-0.2
        pen.lt(3)
        pen.fd(a)
print(pen)
turtle.mainloop()

64.题目：利用ellipse 和 rectangle 画图。

if __name__ == '__main__':
    from Tkinter import *
    canvas = Canvas(width = 400,height = 600,bg = 'white')
    left = 20
    right = 50
    top = 50
    num = 15
    for i in range(num):
        canvas.create_oval(250 - right,250 - left,250 + right,250 + left)
        canvas.create_oval(250 - 20,250 - top,250 + 20,250 + top)
        canvas.create_rectangle(20 - 2 * i,20 - 2 * i,10 * (i + 2),10 * ( i + 2))
        right += 5
        left += 5
        top += 10

    canvas.pack()
    mainloop()
#答案来自菜鸟教程

65.题目：一个最优美的图案。

import math
from tkinter import *


class PTS:
    def __init__(self):
        self.x = 0
        self.y = 0


points = []


def LineToDemo():
    screenx = 400
    screeny = 400
    canvas = Canvas(width=screenx, height=screeny, bg='white')

    AspectRatio = 0.85
    MAXPTS = 15
    h = screeny
    w = screenx
    xcenter = w / 2
    ycenter = h / 2
    radius = (h - 30) / (AspectRatio * 2) - 20
    step = 360 / MAXPTS
    angle = 0.0
    for i in range(MAXPTS):
        rads = angle * math.pi / 180.0
        p = PTS()
        p.x = xcenter + int(math.cos(rads) * radius)
        p.y = ycenter - int(math.sin(rads) * radius * AspectRatio)
        angle += step
        points.append(p)
    canvas.create_oval(xcenter - radius, ycenter - radius,
                       xcenter + radius, ycenter + radius)
    for i in range(MAXPTS):
        for j in range(i, MAXPTS):
            canvas.create_line(points[i].x, points[i].y, points[j].x, points[j].y)

    canvas.pack()
    mainloop()


if __name__ == '__main__':
    LineToDemo()
# 答案来自菜鸟教程

66.题目：输入3个数a,b,c，按大小顺序输出。

a = int(input())
b = int(input()) 
c = int(input())
l = []
l.append(a)
l.append(b)
l.append(c)
l.sort()
for i in range(3):
    print(l[i])

67.题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
程序分析：注意把l.index(min(l))直接当作索引时，交换数值时会出问题。

l = [56,5,4,1,3,8,97,9]
print(l)
min_idx = l.index(min(l))
max_idx = l.index(max(l))
l[0],l[max_idx] = l[max_idx],l[0]
l[-1],l[min_idx] = l[min_idx],l[-1]
print(l)

68.题目：有 n 个整数，使其前面各数顺序向后移 m 个位置，最后 m 个数变成最前面的 m 个数

l = [56,5,4,1,3,8,97,9]
temp = []
n = len(l)
print('请输入一个m,m的值小于',n,':')
m = int(input())
for i in range(m):
    temp.append(l.pop())
for i in range(m):
    l.insert(i,temp[m-i-1])
print(l)

#方法2运用列表的分片
n = 10
m = 5
a = [1,2,3,4,5,6,7,8,9,10]
b = []
b[:] = a[5:]
a[5:] = a[0:5]
a[0:5] = b[:]
print(a)

69.题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
程序分析：注意使用索引来判断索引下的人是否该退出圈子。

l = []
n = int(input("总人数为:"))
for i in range(n):
    l.append(1)
    
i = 0
j = 0

while sum(l)!=1:
    if l[i] != 0:
        j +=1
    if j%3 == 0:
        l[i]=0
    #从头再开始数
    if i==n-1:
        i=0
        continue
    i+=1
print("剩下为第"+str(l.index(max(l))+1)+"位") 

70.题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

def fn(l):
    return len(l)
if __name__=='__main__':
    a = input('请输入字符串，返回字符串长度：')
    print(fn(a))

71.题目：编写input()和output()函数输入，输出5个学生的数据记录。
程序分析：注意先定义一个存储学生数据的数组。

student = []
for i in range(5):
    student.append([[],[]])
def input_stu(student):
    for i in range(5):
        student[i][0] = input("学生名字：")
        student[i][1] = input("成绩：")
    return student
def output_stu(student):
    print(student)
if __name__=='__main__':
    input_stu(student)
    output_stu(student)

72.题目：创建一个链表。

a = []
for i in range(3):
    a.append(input("请输入值："))
print(a)

73.题目：反向输出一个链表

a = []
for i in range(3):
    a.append(input("请输入值："))
print(a[::-1])

74.题目：列表排序及连接。
程序分析：排序可使用 sort() 方法，连接可以使用 + 号或 extend() 方法。

a = [8,4,3,8,3]
b = [3,6,8,4,2]
a.sort()
print(a)
b.sort()
print(b)
print(a+b)
a.extend(b)
print(a)

75.题目：放松一下，算一道简单的题目。

if __name__ == '__main__':
    for i in range(5):
        n = 0
        if i != 1: n += 1
        if i == 3: n += 1
        if i == 4: n += 1
        if i != 4: n += 1
        if n == 3: print(64 + i)

76.题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n
程序分析：按照题意编程即可。

def F(n):
    sum = 0
    if n < 0:
        print('input error')
    elif n == 0:
        print(0)
    elif n%2 == 0:
        for i in range(2,n+1):
            if i%2 == 0:
                sum += 1/i
        print(sum)
    else:
        for i in range(1,n+1):
            if i%2 != 0:
                sum += 1/i
        print(sum)

F(4)

77.题目：循环输出列表

a = ['a','b','c','d','e']
for i in a:
    print(i)

78.题目：找到年龄最大的人，并输出。

def get_keys_by_value(the_dict, the_value):

    rl = []
    for key in the_dict.keys():
        if the_dict[key] == the_value:
            rl.append(key)
    return rl

person = {"li":18,"wang":50,"zhang":20,"sun":22}
temp = []
for value in person.values():
    temp.append(value)
print(get_keys_by_value(person, max(temp)),max(temp))

79.题目：字符串排序。
程序分析：用列表的sort()函数。

def str_sort(n):
    str = []
    for i in range(n):
        str.append(input('请输入第{}个字符串:'.format(i+1)))
    str.sort()
    print(str)

str_sort(2)

80.题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
程序分析：逆向思考，当第五个猴子剩6个桃子时，第一个猴子得到多少只桃子由题可知当到第五只猴子时剩的桃子大于等于6时，海滩上原来有的桃子数才有可能最少，如果6个不对的话则可能为11、16、21…

taozi = 1
temp =1
flag = 0
while flag<4:
    flag = 0
    temp = taozi
    for i in range(5):
        #如果这个if语句能够连续执行5次，则说明最后一次的桃子数找对了，用flag判断
        #用temp是为了防止if语句执行次数小于五次也会导致monkey变化，紧接着else语句更新最后一个桃子值时发生错误
        if temp%4 == 0:
            temp = (temp*5)/4 + 1
            flag += 1
        else:
            taozi = taozi + 5
            break
print(temp)

#正推，来自峰哥
def fentao(monkey,num):
    if(monkey==0):
        return (1,num)
    if((num-1)%5!=0):
        return (-1,num)
    num=(num-1)*4/5

    return fentao(monkey-1,num)

for i in range(1,4000):
    monkey,num=fentao(5,i)
    if(monkey==1):
        print(i)

81.题目：809*??=800*??+9*?? 其中??代表的两位数, 809*??为四位数，8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。
程序分析：按条件判断即可。

for i in range(10,100):
    if i*809 == (800*i)+(9*i) and len(str(8*i)) == 2 and len(str(9*i))==3:
        print(i,809*i)

82.题目：八进制转换为十进制

def F(n):
    sum = 0
    for i in range(len(str(n))):
        sum += 8 * (8**i)
    return sum
print(F(19))

83.题目：求0—7所能组成的奇数个数。
程序分析：
1位的时候是p(4,1)=4个。(1,3,5,7)
2位的时候是p(7,1)p(4,1)=74个。(十位可为1-7任意一个数，个位为1,3,5,7中一个)
3位的时候是p(7,1)p(8,1)p(4,1)=784个。(百位为1-7中，十位0-7中，个位1,3,5,7中)
4位的时候是p(7,1)p(8,1)p(8,1)**p(4,1)=788*4个。

s = 4
m = 4
#
for i in range(1,8):
    if i == 1:
        s=s*7
        m+=s
    else:
        s=s*8
        m+=s
print(m)

84.题目：连接字符串。

str = "-";
seq = ("a", "b", "c"); # 字符串序列
print(str.join( seq ));

85.题目：输入一个奇数，然后判断最少几个 9 除于该数的结果为整数。
程序分析：999999 / 13 = 76923。

n = int(input('请输入一个奇数:'))
res = 9
i = 0
while True:
    if res%n == 0:
        print(res,res/n)
        break
    else:
        i += 1
        res += res*(10**i)

86.题目：两个字符串连接程序。

a = 'sfebre'
b = 'verbrtvb'
s = a+b
print(s)

87.题目：回答结果（结构体变量传递）。

class student:
    x = 0
    c = 0
def f(stu):
    stu.x = 20
    stu.c = 'c'
a= student()
a.x = 3
a.c = 'a'
f(a)
print(a.x,a.c)

88.题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的*。

for i in range(7):
    n = int(input())
    for j in range(n):
        print('*',end='')
    print()

89.题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

l = []
for i in range(4):
    l.append(int(input('请输入四个数字（分四次输入）：')))
print(l)
for i in range(4):
    l[i] = (l[i]+5)%10
temp = l[0]
l[0] = l[3]
l[3] = temp
temp = l[1]
l[1] = l[2]
l[2] = temp
print(l)

90.题目：列表使用实例。

#list  
#新建列表  
testList=[10086,'中国移动',[1,2,4,5]]  
  
#访问列表长度  
print(len(testList))  
#到列表结尾  
print(testList[1:])  
#向列表添加元素  
testList.append('i\'m new here!')  
  
print(len(testList))
print(testList[-1])
#弹出列表的最后一个元素  
print(testList.pop(1))  
print(len(testList)) 
print(testList)  

91.题目：时间函数举例1。

import time
print(time.ctime(time.time())) #time ctime() 函数把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式
print(time.asctime(time.localtime(time.time()))) # time asctime() 函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串
print(time.asctime(time.gmtime(time.time())))

92.题目：时间函数举例2。

import time
start = time.time()
print(start)
for i in range(3000):
    n = 0
end = time.time()
print(end)
print(end - start)

93.题目：时间函数举例3。

import time
start = time.perf_counter()
print(start)
for i in range(3000):
    n = 0
end = time.perf_counter()
print(end)
print('different is %6.10f' % (end - start))
#time.time()是统计的wall time(即墙上时钟)，也就是系统时钟的时间戳（1970纪元后经过的浮点秒数）。所以两次调用的时间差即为系统经过的总时间。
#time.clock()是统计cpu时间 的工具，这在统计某一程序或函数的执行速度最为合适。两次调用time.clock()函数的插值即为程序运行的cpu时间。
#python3.8中删除了time.clock

94.题目：时间函数举例4,一个猜数游戏，判断一个人反应快慢。

import time
n = 25
start = time.time()
for i in range(100):
    a = int(input('请输入你猜的数：'))
    if a > n:
        print('请输入一个更小的数')
    elif a < n:
        print('请输入一个更大的数')
    elif a==n:
        print('正确')
        end = time.time()
        break
print('反应时间为 %6.3f' % (end-start))

95.题目：字符串日期转换为易读的日期格式。

from dateutil import parser
dt = parser.parse("Oct 13 2019 11:55AM")
print(dt)

96.题目：计算字符串中子串出现的次数

a = 'favhfahcviowfciuqcih'
b = 'fa'
n = a.count(b)
print(n)

97.题目：从键盘输入一些字符，逐个把它们写到磁盘文件上，直到输入一个 # 为止。

fp = open('1.txt','w')
for i in range(1000):
    a = input()
    if a!='#':
        fp.write(a)
    else:
        fp.close()
        break

98.题目：从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘文件"test"中保存。

a = input('请输入字符串：')
a = a.upper()
fp = open('1.txt','w')
fp.write(a)
fp.close()

99.题目：有两个磁盘文件A和B,各存放一行字母,要求把这两个文件中的信息合并(按字母顺序排列), 输出到一个新文件C中。

A = open('1.txt')
a = A.read()
A.close()
B = open('test.txt')
b = B.read()
B.close()
c = list(a+b)
c.sort()
print(c)
l = ''
l = l.join(c)
print(l)
fp = open('C.txt','w')
fp.write(l)
fp.close()

100.题目：列表转换为字典。

a = [1,'apple']
b = [2,'banana']
c = [3,'orange']
print(dict([a,b,c]))

本文地址：https://blog.csdn.net/weixin_40585997/article/details/109644709