练习：
1.猜拳游戏
键盘输入 剪刀（0）石头（1）布（2），电脑随机生成[0, 2]，并判断输赢
不使用字典的情况下
方法1

from random import randint
player = int(input("剪刀石头布，请出拳："))
computer = randint(0, 2)
if (player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1):
    print("恭喜玩家胜利")
elif player == computer:
    print("平手")
else:
    print("电脑胜利")

方法2

from random import randint
player = int(input("剪刀石头布，请出拳："))
computer = randint(0, 2)
if player == 0:
    if computer == 2:
        print("恭喜玩家胜利")
    elif computer == 1:
        print("电脑胜利")
elif player == 1:
    if computer == 0:
        print("恭喜玩家胜利")
    elif computer == 2:
        print("电脑胜利")
elif player == 2:
    if computer == 1:
        print("恭喜玩家胜利")
    elif computer == 0:
        print("电脑胜利")
else:
    print("平手")

方法3

#while方法
from random import randint
i = 1
while i == 1:
    player = int(input("剪刀[0]石头[1]布[2]，请出拳："))
    computer = randint(0, 2)
    if player != 0 and player != 1 and player != 2:
        print("输入错误，请重新输出")

    elif (player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1):
        print("恭喜玩家胜利")
        i = 2
    elif player == computer:
        print("平手")
    else:
        print("电脑胜利")

2.while循环嵌套
在控制台中输出下面图形

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

方法1

i = 1
while i < 6 :
    print("* "*i)
    i += 1

方法2

i = 1
while i < 6 :
    j = 1
    while j <= i:
        print("* ",  end='')
        j += 1
    print(end='\n')
    i += 1

3.九九乘法表
方法1

#while循环实现
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print("%dX%d=%-2d"%(i,j,i*j),end = ' ')
        j += 1
    print()
    i += 1

方法2

#for循环编写九九乘法表
for i in range(1, 10):
    for j in range(1, 10):
        print(j, "X", i, "=", i*j, "\t", end="")#默认结尾是换行的，变成换行的只需要end=“”即可
        if i == j:
            print("")

4.猜数字

import random
min_num = int(input("请给定要猜的最大数字:"))
max_num = int(input("请给定要猜的最小数字:"))
#随机数生成一个数字，让用户猜这个数字
generate_num = random.randint(min_num, max_num)
count = 0
while True:
   count +=1
   guess_number = int(input("输入您猜的数字:"))
   if guess_number < generate_num:
       print("您猜小了")
   elif guess_number > generate_num:
       print("您猜大了")
   else:
       if count ==1:
           print("你也太厉害了吧，1次就猜对了，这是高手")
       elif count > 1 and count < 6:
           print("恭喜只用了：", count, "次就猜对了数字")
       else:
           print("你也太菜了", count, "次就才猜得出来,洗洗睡吧")

5.我想买车，买什么车决定于我在银行有多少存款
如果我的存款超过500万，我就买路虎
否则，如果我的存款超过100万，我就买宝马
否则， 如果我的存款超过50万，我就买迈腾
否则， 如果我的存款超过10万，我就买福特
否则， 如果我的存款10万以下 ，我买比亚迪

money = int(input('查看我的存款:'))
if money >= 500:
    print("我可以买路虎啦！")
elif money >= 100 and money < 500:
    print("我可以买宝马啦！")
elif money >= 50 and money < 100:
    print("我还可以买迈腾！")
elif money >= 10 and money < 50:
    print("我只能买福特了.")
else:
    print("我就能买的起比亚迪了.")

6.输入小明的考试成绩，显示所获奖励
成绩==100分，爸爸给他买辆车
成绩>=90分，妈妈给他买MP4
90分>成绩>=60分，妈妈给他买本参考书
成绩<60分，什么都不买

score = int(input('小明的考试成绩:'))
if score == 100:
    print("小明考了满分，爸爸给买辆车。")
elif score >= 90 and score < 100:
    print("成绩还不错，妈妈给买MP4")
elif score >= 60 and score < 90:
    print("需要努力，妈妈给买参考书")
else:
    print("成绩不好，什么都不买")

7.输入n的值，求出n的阶乘。
方法1

n = int(input("请输入数字n："))
factorial = 1
for i in range(1, n+1):
    factorial *= i 
print(factorial)

方法2

#使用math库
import math
n = int(input("请输入数字n："))
print(math.factorial(n))  

8.折纸上月球
大家都看过科幻片《火星救援The Martian》吧，电影里航天员们在太空中碰到各种情况都是靠计算机模拟、计算来解决问题的。
我们在地球上也可以靠高大上的Python语言来解决问题。现在问题来了：我们都知道，月亮在一个椭圆形的轨道上绕地球公转，因此两者的距离是不断变化的，它们的最小距离是363300公里。现在我们都想去月球旅游（地球玩腻了，想换个口味），但是坐火箭上天一次就带辣么几个人，我们等不及。好消息，好消息，厂家现在开发出逆天神技——折纸上月球！
只需一张很大的A4纸，厚度为0.088毫米，折一次就0.176毫米，折两次就0.352毫米……多折几次就很高了。
穿上冲锋衣，拿上登山杖，带上自拍杆，我们爬着就可以上月球发朋友圈了。我就想问一句：要上月球，我们到底需要折多少次？

方法1

n=0
d=0.088
while d <= 363300*1000*1000:
    d = 2 * d
    n = n + 1
print(n)

方法2

count = 0
n = 0.088
while 1:
   if(n>=363300*1000*1000):
       break
   n=n*2
   count=count+1
print(count)

9.篮球弹跳高度的计算
书呆子就是书呆子，打个篮球脑子也不闲着。这种人说好听的叫‘geek’，说不好听的就是叫‘nerd’。
这不，书呆子看着篮球在想：如果篮球从某一高度落下，每次落地后反弹回原来高度的一半再落下。
那么球在第10次落地时，共经过多少米呢? 第10次反弹多高？ （你问我这个题是不是瞎编的？当然是了，你什么时候见过书呆子打篮球？）
输入：输入一个整数h，单位是米，表示球的初始高度。
输出：输出包含两行：
第1行：到球第10次落地时，一共经过的距离。
第2行：第10次弹跳的高度。
例如输入：20 对应输出：第一行：59.921875 第二行：0.01953125

h = int(input("请输入球的初始高度："))
s = h
for i in range(1,11):
   h = h * 0.5
   s = s + h*2
print("一共经过{}\n第十次高度为{}\n".format(s,h))

10.我国现有13亿人口，设每年增长0.8%，编写程序，计算多少年后达到26亿？

num = 13
year = 0
while 1:
    if num>=26:
        break
    num=num*(1+0.008)
    year += 1
print(f"经过{year}年，人口达到26亿")

11.求1！+2！+3！+4！+5！的和。
方法1

import math
s = sum([math.factorial(i) for i in range(1, 6)])
print(s)

方法2

sum=1
count=0
for i in range(1,6):
    sum *= i
    count += sum
print(count)

13.星号三角形：读入一个整数N，N是奇数，输出由星号字符组成的等边三角形
要求：第1行1个星号，第2行3个星号，第3行5个星号，依次类推，最后一行共N的星号。
输入：3
输出：

  *
* * *

方法1

N = int(input('输入一个奇数N:'))
line = int(N / 2) + 1
m = 1
for i in range(line):
  print((' ' * ((N - m) // 2)) + ('*' * m) + (' ' * ((N - m) // 2)))
  m += 2

方法2

N = int(input('输入一个奇数N:'))
i = 0
while i <= N:
    space = ' ' * ((N - i) // 2)
    n = '*' * (i + 1)
    print(f'{space}{n}{space}')
    i += 2

方法3

N = int(input('输入一个奇数N:'))
for i in range(0, N + 1):
     for j in range(0, N - i):
         print(end=' ')
     for k in range(N - i, N):
         print('*',end=' ')
     print('')

14.分页实现内容
a.通过for循环创建301条数据,数据类型不限,如:

zhangsan-1     zhangsan1@neuedu.com      pwd1
zhangsan-2     zhangsan2@neuedu.com      pwd2
zhangsan-3     zhangsan3@neuedu.com      pwd3

提示用户 请输入要查看的页码，当用户输出指定页码，也显示指定数据
注意:
每页显示10条数据

while True:
    j = int(input('请输入要查看的页码:'))
    #所有数据
    list = []
    for i in range(1, 301):
        list.append(f'zhangsan-{i}, zhangsan{i}@neuedu.com, pwd{i}')
    if j == 1:
        print('您正在访问第1页')
        for x in list[0:10]:
            print([x])
        break
    elif j > 30:
        print('没有该页码，请重新输入')
    else:
        print(f'您正在访问第{j}页')
        for x in list[j*10-10 : j*10]:
            print([x])
        break

15.(模拟龟兔赛跑)本练习中要模拟龟兔赛跑的寓言故事。用随机数产生器建立模拟龟兔赛跑的程序。 对手从70个方格的第1格开始起跑，每格表示跑道上的一个可能位置，终点线在第70格处。 第一个到达终点的选手奖励一个新鲜萝卜和莴苣。兔子要在山坡上睡一觉，因此可能失去冠军。 有一个每秒钟滴答一次的钟，程序应按下列规则调整动物的位置：

image

用变量跟踪动物的位置(即位置号1到70)。每个动物从位置1开始，如果动物跌到第1格以外，则移回第1格。 产生随机整数1≤i≤10)，以得到上表中的百分比。对于乌龟，1≤i≤5时快走，6≤i≤7时跌跤，8≤i≤10时慢走，兔子也用相似的方法。 起跑时，打印： BANG !!!!! AND THEY' RE OFF !!!!! 时钟每次滴答一下(即每个重复循环)，打印第70格位置的一条线，显示乌龟的位置T和兔子的位置H。 如果两者占用一格，则乌龟会咬兔子，程序从该位置开始打印 OUCH!!!。除T、H和OUCH!!!以外的其他打印位置都是空的。 打印每一行之后，测试某个动物是否超过了第70格，如果是,则打印获胜者，停止模拟。 如果乌龟赢，则打印TORTOISE WINS!!!YAY!!!。如果兔子赢，则打印Hare wins．Yush。 如果两个动物同时赢，则可以同情弱者，让乌龟赢，或者打印It's a tie。如果两者都没有赢，则再次循环，模拟下一个时钟滴答。 准备运行程序时，让一组拉拉队看比赛，你会发现观众有多么投入。

# -*- coding:utf-8 _*-
# @Time    : 公元 2019/11/07 21:08
# @Author  : WenTing Men
# @Email   : wentingmen@163.com
# @File    : demo5.py
# @Software: PyCharm
from random import randint
print("BANG !!!!! AND THEY' RE OFF !!!!! ")
n = 1
hPos = 0#兔子坐标
tPos = 0#乌龟坐标
while n == 1:
    runway = '-'*70
    i = randint(0, 10) + 1
    #龟
    if i <= 5:
        tPos += 3
    elif 5 < i <= 7:
        tPos -= 6
        if tPos <= 1:
            tPos = 1
    else:
        tPos += 1
    #兔
    if i <= 2:
        hPos = hPos
    elif 3 <= i <= 4:
        hPos += 9
    elif i == 5:
        hPos -= 12
        if hPos <= 1:
            hPos = 1
    elif 6 <= i <= 8:
        hPos += 1
    else:
        hPos -= 2
        if hPos <= 1:
            hPos == 1
    if tPos >= 70 or hPos >= 70:
        n = 2
    if tPos == hPos:
        runway = runway[:tPos] + 'OUCH!!!' + runway[tPos+5:]
        #除去字符串OUCH!!!长度，补上TH长度占位，T跟H在同一个位置
    else:
        runway = runway[:tPos] + 'T' + runway[tPos:]
        runway = runway[:hPos] + 'H' + runway[hPos:]
    print(runway)

if tPos >= 70:
    print("TORTOISE WINS!!!YAY!!!")

elif hPos >= 70:
    print("Hare wins．Yush。")

else:
    print("it's a tie")

16.需求
给定单词数组（不少于10个），程序随机选择其中的一个，并显示单词字符长度个横线（-），用户有5次猜测机会，用户每次猜一个字母，如果正确，则将在相应的位置上显示出来；如错误则猜测机会减一，重复该过程，直至单词的全部字母全部猜出或者猜测次数用完，最后宣布用户胜利或失败。
实例
例如随机选出的单词是apple，程序先打印- - - - - 用户输入p，程序打印 -pp-- 用户输入e，程序打印 -pp-e 用户输入t，程序打印 -pp-e 您还有4次机会 用户输入a，程序打印 app-e 用户输入l，程序打印 apple 恭喜您，取得胜利。

# -*- coding:utf-8 _*-
# @Time    : 公元 2019/11/07 21:08
# @Author  : WenTing Men
# @Email   : wentingmen@163.com
# @File    : demo5.py
# @Software: PyCharm

import random
words = ['pen', 'water', 'banana', 'range', 'apple', 'lemon', 'cherry', 'pear', 'coconut', 'peach']
word = words[random.randint(0,len(words) - 1)]
list1 = list('_'*len(word))
print('_'*len(word))
n = 1
while n < 6:
    guess = input(f"请输入一个字母,您还有{6-n}次机会")
    if guess in word:
        for i, c in enumerate(word):
            if c == guess:
                list1[i] = guess
        print("".join(list1))
        l2 = "".join(list1)
        if "_" not in l2:
            print("恭喜您全猜对了，胜利！")
            break
    n += 1

if n == 6:
    print("没有机会了，挑战失败")

17.有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。
方法1

# -*- coding: utf-8 -*-
# @Time    : 2019/11/11 13:02
# @Author  : WenTing Men
# @Email   : wentingmen@163.com
# @File    : 练习.py
# @Software: PyCharm
fenzi = 2 # 分子
fenmu = 1 # 分母
sum_t = 0
for i in range(1, 21):
    a = fenzi
    b = fenmu
    sum_t += (a / b)
    fenzi = a + b
    fenmu = a
print(sum_t)

方法2

from functools import reduce
def compute():
    result = 0
    lst = []
    fenzi = 2
    fenmu = 1
    lst.append(fenzi/fenmu)
    for i in range(19):
        fenmu, fenzi = fenzi, fenmu + fenzi
        # tmp = fenzi
        # fenzi = tmp + fenmu
        # fenmu = tmp
        lst.append(fenzi/fenmu)
    #for k in lst:
    #   result += k
    #
    result = reduce(lambda  x, y: x + y, lst )
    return  result
print(compute())

18.给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

num = input('输入一个不多于5位的正整数:')
l = len(num)
print(f'这个数是{l}位数')
n = num[::-1]
for i in n:
    print(i)

19.有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

n = int(input('请输入人数n：'))
l1 = list(range(1, n+1))
count = 0
while len(l1) >= 1:
    l = l1[:]
    for i in range(0, len(l)):
        count = count + 1
        if count % 3 == 0:
            l1.remove(l[i])

print(f'最后留下的是原来的第 {l[0]} ')

20.编写一个程序，根据控制台输入的事务日志计算银行帐户的净金额。 事务日志格式如下所示：
D 100
W 200
D表示存款，而W表示提款。
假设为程序提供了以下输入：
D 300
D 300
W 200
D 100
然后，输出应该是：
500

total = 0
while True:
    d = input('请输入事务日志：')
    if not d:
        break
    event_log = d.split(" ")
    nub = int(event_log[1])
    if event_log[0] == "D":
        total += nub
    elif event_log[0] == "W":
        total -= nub

print (total)

21.机器人从原点（0,0）开始在平面中移动。 机器人可以通过给定的步骤向上，向下，向左和向右移动。 机器人运动的痕迹如下所示：
UP 5
DOWN 3
LETF 3
RIGHT 2
方向之后的数字是步骤。 请编写一个程序来计算一系列运动和原点之后距当前位置的距离。如果距离是浮点数，则只打印最接近的整数。
例：如果给出以下元组作为程序的输入：
UP 5
DOWN 3
LETF 3
RIGHT 2
然后，程序的输出应该是：2

import math
while True:
    dirction = input("请输入方向：")
    if not dirction:
        break
    dirction = dirction.split(" ")
    if dirction[0] == "UP":
       u  = int(dirction[1])
    elif dirction[0] == "DOWN":
       d  = int(dirction[1])
    elif dirction[0] == "LETF":
       l = int(dirction[1])
    elif dirction[0] == "RIGHT":
       r = int(dirction[1])
    #
x = abs(u-d)
y = abs(l-r)
print(int(math.sqrt(x**2+y**2)))

22.统计单词出现次数

w = "I'm a boby, I'm a girl. When it is true, it is ture. that are cats, the red is red."
lw = dict([(i,w.split().count(i)) for i in w.split()])
print(lw)

23.奥运会足球分组
已知有十六支男子足球队参加2008 北京奥运会。写一个程序，把这16 支球队随机分为4 个组。采用List集合和随机数
2008 北京奥运会男足参赛国家：
科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利
提示：分配一个，删除一个
方法1

from random import randint
list = ['科特迪瓦', '阿根廷', '澳大利亚', '塞尔维亚', '荷兰', '尼日利亚', '日本', '美国', '中国', '新西兰', '巴西', '比利时', '韩国', '喀麦隆', '洪都拉斯', '意大利']
#print(len(list))
#16
for j in range(4):
    new = []
    for i in range (4):
        chouqian = randint(0, len(list)-1)
        new.append(list[chouqian])
        list.remove(list[chouqian])
    print(f'第{j+1}组{new}')

方法2

import random
worlds = '科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利'
worlds_lst = worlds.split('，')
print(worlds_lst)
dic = {}
for i in range(4):
    group_lst = []
    for j in range(4):
        select_world = random.choice(worlds_lst)
        group_lst.append(select_world)
        worlds_lst.remove(select_world)
    dic[i+1] = group_lst
for k,v in dic.items():
    print('第' + str(k) + '组')
    for country in v:
        print(country,end=' ')
    print()

24.根据用户的输入，产生多级列表的效果，中途可按b返回，q直接退出

*********************** 省 ************************
1 山东
2 江苏
3 浙江
4 安徽
5 广东
请输入省编号,或输入q(quit)退出：1
*********************** 市 ************************
1 青岛
2 济南
3 烟台
请输入市编号,或输入b(back)返回上级菜单，或输入q(quit)退出：2
*********************** 县 ************************
1 历城
2 槐荫
3 高新
4 长青
5 章丘
输入b(back)返回上级菜单，或输入q(quit)退出：3
输入非法！
*********************** 县 ************************
1 历城
2 槐荫
3 高新
4 长青
5 章丘
输入b(back)返回上级菜单，或输入q(quit)退出：b
*********************** 市 ************************
1 青岛
2 济南
3 烟台
请输入市编号,或输入b(back)返回上级菜单，或输入q(quit)退出：b
*********************** 省 ************************
1 山东
2 江苏
3 浙江
4 安徽
5 广东
请输入省编号,或输入q(quit)退出：5
*********************** 市 ************************
1 深圳
2 广州
3 东莞
请输入市编号,或输入b(back)返回上级菜单，或输入q(quit)退出：1
*********************** 县 ************************
1 罗湖
2 福田
3 南山
4 宝安
5 布吉
输入b(back)返回上级菜单，或输入q(quit)退出：1
输入非法！
*********************** 县 ************************
1 罗湖
2 福田
3 南山
4 宝安
5 布吉
输入b(back)返回上级菜单，或输入q(quit)退出：b
*********************** 市 ************************
1 深圳
2 广州
3 东莞
请输入市编号,或输入b(back)返回上级菜单，或输入q(quit)退出：b
*********************** 省 ************************
1 山东
2 江苏
3 浙江
4 安徽
5 广东
请输入省编号,或输入q(quit)退出：q

dict = {
    '山东' : {
        '青岛' : ['四方','黄岛','崂山','李沧','城阳'],
        '济南' : ['历城','槐荫','高新','长青','章丘'],
        '烟台' : ['龙口','莱山','牟平','蓬莱','招远']
    },
    '江苏' : {
        '苏州' : ['沧浪','相城','平江','吴中','昆山'],
        '南京' : ['白下','秦淮','浦口','栖霞','江宁'],
        '无锡' : ['崇安','南长','北塘','锡山','江阴']
    },
    '浙江' : {
        '杭州' : ['西湖','江干','下城','上城','滨江'],
        '宁波' : ['海曙','江东','江北','镇海','余姚'],
        '温州' : ['鹿城','龙湾','乐清','瑞安','永嘉']
    },
    '安徽' : {
        '合肥' : ['蜀山','庐阳','包河','经开','新站'],
        '芜湖' : ['镜湖','鸠江','无为','三山','南陵'],
        '蚌埠' : ['蚌山','龙子湖','淮上','怀远','固镇']
    },
    '广东' : {
        '深圳' : ['罗湖','福田','南山','宝安','布吉'],
        '广州' : ['天河','珠海','越秀','白云','黄埔'],
        '东莞' : ['莞城','长安','虎门','万江','大朗']
    }
}

flag = True
while flag:
    province_list = []
    for i in dict.keys():
        province_list.append(i)
    for i, j in enumerate(province_list):
        i += 1
        print(i, j)
    num = input('请输入省编号,或输入q(quit)退出:')
    if num == 'q':
        flag = False
    else:
        num = int(num)
        if num <= len(dict):
            num_1 = num - 1
            province = province_list[num_1]
        else:
            print('输入非法！')

        while flag:
            city_list = []
            for i in dict[province]:
                city_list.append(i)
            for i, j in enumerate(city_list):
                i += 1
                print(i, j)
            num = input('请输入市编号,或输入b(back)返回上级菜单，或输入q(quit)退出：')
            if num == 'q':
                flag = False
            elif num == 'b':
                break
            else:
                num = int(num)
                num_1 = num - 1
                if num <= len(city_list):
                    city = city_list[num_1]
                    country_list = []
                    for i, j in enumerate(dict[province][city][0:]):
                        i += 1
                        country_list.append(j)
                        print(i, j)
                else:
                    print('输入非法！')
                num = input('请输入县编号,或输入b(back)返回上级菜单，或输入q(quit)退出：')
                if num == 'q':
                    flag = False
                elif num == 'b':
                    continue
                else:
                    num = int(num)
                    num_1 = num - 1
                    if num <= len(country_list):
                        country = country_list[num_1]
                    else:
                        print('输入非法！')
            flag = False

            print(f'{province}：{city}：{country}')

25.题目：写一个摇骰子游戏，要求用户压大小，赔率一赔一。
要求：三个骰子，摇大小，每次打印摇骰子数。
----- 游戏开始 -----
请下注， big or small：big
下注金额：100
----- 摇骰子 -----
骰子点数 [3, 1, 6] 10
很遗憾， 你输了100元， 你现在的本金900 元
----- 游戏开始 -----
请下注， big or small：small
下注金额：200
----- 摇骰子 -----
骰子点数 [6, 4, 2] 12
很遗憾， 你输了200元， 你现在的本金700 元
----- 游戏开始 -----
请下注， big or small：small
下注金额：200
----- 摇骰子 -----
骰子点数 [1, 6, 1] 8
恭喜， 你赢了200元， 你现在的本金900 元
----- 游戏开始 -----
请下注， big or small

from random import randint
def game():
    benjin = 1000
    while benjin > 100:
        print(' 游戏开始 '.center(20, '-'))
        big_or_small = input('请下注， big or small:')
        money = input('下注金额:')
        money = int(money)
        print(' 摇骰子 '.center(20, '-'))
        point = [randint(1, 6) for _ in range(3)]
        print(f'骰子点数{point}')
        if sum(point) <= 10 and big_or_small == 'small':
            benjin = benjin + money
            print(f'恭喜， 你赢了{money}元， 你现在的本金{benjin} 元')
        elif sum(point) <= 10 and big_or_small == 'big':
            benjin = benjin - money
            print(f'很遗憾， 你输了{money}元， 你现在的本金{benjin} 元')
        elif sum(point) > 10 and big_or_small == 'big':
            benjin = benjin + money
            print(f'恭喜， 你赢了{money}元， 你现在的本金{benjin} 元')
        elif sum(point) > 10 and big_or_small == 'small':
            benjin = benjin - money
            print(f'很遗憾， 你输了{money}元， 你现在的本金{benjin} 元')
game()

26.判断用户输入的变量名是否合法:

• 变量名可以由字母,数字或者下划线组成
• 变量名只能以字母或者下划线开头

分析：
1.判断变量名的第一个元素是否为字母或者下划线 s[0]
2.如果第一个元素符合条件,判断除了第一个元素之外的其他元素s[1:]
方法1

def check(s):
    if s[0].isalpha() or s[0] == '_':
        for i in s[1:]:
            if not(i.isalnum() or i =='_'):
                print(f'{s}变量名不合法' )
        else:
            print(f'{s}变量名合法')
    else:
        print(f'{s}变量名不合法')
        
s = input('请输入一个的变量名:')
check(s)

方法2

while True:
    tmp = input('请输入一个字符串：')
    if tmp == 'quit':
        break
    if tmp[0] == '_' or tmp[0].isalpha():
        # print('可能是合法的字符串')
        for c in tmp[1:]:
            if c == '_' or c.isalnum():
                continue
            else:
                print('不是合法的字符串')
                break
        else:
           print('是合法的字符串')
    else:
        print('不是合法的字符串')

27.给定一个字符串来代表一个学生的出勤纪录，这个纪录仅包含以下三个
字符：
'A' : Absent，缺勤
'L' : Late，迟到
'P' : Present，到场
如果一个学生的出勤纪录中不超过一个'A'(缺勤)并且不超过两个连续的'L'(迟到),
那么这个学生会被奖赏。
你需要根据这个学生的出勤纪录判断他是否会被奖赏。
示例 1:
输入: "PPALLP"
输出: True
示例 2:
输入: "PPALLL"
输出: False
方法1

def form(list):
    list1 = dict([(i,list.count(i)) for i in list])
    print(list1)
    if list1['A'] <= 1 and 'LLL' not in list:
        print('True')
    else:
        print('False')
list = input('输入出勤记录：')
form(list)

方法2

while True:
    tmp = input('请输入一个字符串：')
    if tmp == 'quit':
        break
    if tmp.count('A') + tmp.count('P') + tmp.count('L') < len(tmp):
        print('输入有误')
    if tmp.count('A') < 2 and tmp.count('LLL') == 0:
        print('True')
    else:
        print('False')

28.输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例
如，输入”They are students.”和”aeiou”，
则删除之后的第一个字符串变成”Thy r stdnts.”
输入描述:
每个测试输入包含2个字符串
输出描述:
输出删除后的字符串
示例1:
输入
They are students.
aeiou
输出
Thy r stdnts.
方法1

s1 = input('请输入第一个字符串')
s2 = input('请输入第二个字符串')

for i in s1:
    if i in s2:
        s1 = s1.replace(i,'')
print(s1)

方法2

s1 = input('请输入第一个字符串')
s2 = input('请输入第2个字符串')
for c2 in s2:
    s1 = s1.replace(c2,'')
print(s1)

29.编写一个函数calculate, 可以接收任意多个数,返回的是一个元组.
元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所有数.
方法1

import numpy as np
def calculate(*args):
    '''
    :param *args: 接收任意多个数
    :return: 第一个值为所有参数的平均值, 第二个值为大于平均值的所有数
    '''
    mean_num = np.mean(args)
    l =[]
    for i in args:
        if mean_num < i:
            l.append(i)
    return mean_num, l
print(calculate(1,2,2,4,6))

方法2

def calculate(*param):
    avg = sum(param) / len(param)
    # lst = []
    # for i in param:
    #     if i > avg:
    #         lst.append(i)
    lst = list(filter(lambda x:x>avg,param))
    return avg,lst
result = calculate(1,2,3,4,5)
print(result)

30.编写一个函数, 接收字符串参数, 返回一个元组,
元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
例如
输入：'hello WORLD'
输出：（5，5）

def letter_count(str1):
    '''
    :param str1:
    :return: 第一个值为大写字母的个数, 第二个值为小写字母个数
    '''
    upper_count = 0
    lower_count = 0
    for i in str1:
        if i.isupper():
            upper_count += 1
        elif i.islower():
            lower_count += 1
        else:
            continue
    return upper_count, lower_count

#str1 = input('输入字符串')
print(letter_count('hello WORLD'))

31.编写函数, 接收一个列表(包含30个1~100之间的随机整形数)
和一个整形数k, 返回一个新列表.
函数需求:

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

from random import randint
list = [randint(1, 100) for i in range(30)]
k = int(input('输入一个小于等于30的整数'))
print(list)
def sort_r(list, k):
    '''
    :param list: 包含30个1~100之间的随机整形数
    :param k: 一个整形数k
    :return:
    '''

    print(list[:k][::-1]+list[k:][::-1])

sort_r(list, k)

32.模拟轮盘抽奖游戏
轮盘分为三部分: 一等奖, 二等奖和三等奖;
轮盘转的时候是随机的,
如果范围在[0,0.08)之间,代表一等奖,
如果范围在[0.08,0.3)之间,代表2等奖,
如果范围在[0.3, 1.0)之间,代表3等奖,
模拟本次活动1000人参加, 模拟游戏时需要准备各等级奖品的个数.

import random
Count = {
    '一等奖': (0, 0.08),
    '二等奖': (0.08, 0.3),
    '三等奖': (0.3, 1.0)
}
def reward():
    num = random.random()
    for k, v in Count.items():
        if v[0] <= num < v[1]:
            return k
people = {}

for i in range(1000):
    res = reward()
    if res not in people:
        people[res] = 1
    else:
        people[res] += 1
for k, v in people.items():
    print(k, v, '人')

33.题目需求:
对于一个十进制的正整数， 定义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,
且kf(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
s = input('k,a,b')
list = []
for item in s.split():
    list.append(int(item))
k,a,b=list
count=0
for i in range(a,b+1):
    if k*f(i) == i:
        count += 1
print(count)