Pythoh 测试
1、2000<=x<=3200，x 可以被7整除，但不能是5的倍数。顺序打印数字 x，以逗号分隔。
print(','.join([str(i) for i in range(2000, 3201) if not i%7 and i % 5]))
2、输入自然数 n 计算 n 的阶乘。
示例 输入：8，输出：40320
def fact(x):
return x * fact(x - 1) if x else 1
print(fact(int(input())))
3、输入整数 n，生成字典键为 1 到 n 之间的整数（包括1，n），值为对应键的平方。然后打印字典。
示例 输入：4，输出：{1：1、2：4、3：9、4：16 }
n = int(input())
d = {}
for i in range(1, n + 1):
d[i] = i * i
print(d)
# 字典推导式
print({i: i * i for i in range(1, int(input()) + 1)})
4、输入一系列逗号分隔的数字，生成包含每个数字的列表和元组。
示例 输入：34,67,55，输出：[‘34’,‘67’,‘55’]（‘34’,‘67’,‘55’）
l = input().split(',')
print(l,tuple(l))
5、定义一个至少具有两个方法的类：getString 从控制台输入中获取字符串 ，printString 以大写形式打印该字符串。还请包括简单的测试功能来测试类方法。
class InputOutString:
def getString(self):
self.s = input()
def printString(self):
print(self.s.upper())
strObj = InputOutString()
strObj.getString()
strObj.printString()
6、根据给定的公式计算并打印值：q =(2 * c * d / h)的平方根，c = 50，h = 30 。d 是变量，其值以逗号分隔的顺序输入到程序中。
示例 输入：100,150,180 输出：18,22,24
c, h = 50, 30
print(','.join([str(int((2 * c * float(x) / h)**0.5)) for x in input().split(',')]))
7、 输入 x，y 两个数字以逗号分割，生成一个二维列表。列表的第 i 行和第 j 列中的元素值应为 i * j。注意：i = 0,1 …,x-1; j = 0,1 …,y-1。
示例 输入：3,5，输出：[[0，0，0，0，0]，[0，1，2，3，4]，[ 0，2，4，6，8]]
x, y = input().split(',')
print([[i * j for i in range(int(y))] for j in range(int(x))])
8、以逗号分隔的单词序列作为输入，按字母顺序对单词进行排序后以逗号分隔的顺序打印这些单词。
示例 输入：Without,bag,hello,world ，输出：bag,hello,Without,world
print(','.join(sorted(input().split(','), key=str.lower)))
9、编写一个程序，接受行的顺序作为输入，并在将句子中的所有字符都大写之后打印行。
示例 输入：Hello world Practice，输出：HELLO WORLD PRACTICE
lines = []
while s := input(): # := (>= 3.8)
lines.append(s.upper())
for sentence in lines:
print(sentence)
10、输入一系列由空格分隔的单词，在删除所有重复的单词，将其按字母顺序排序后打印这些单词。
示例 输入：hello world and practice makes perfect again hello world，输出：again and hello makes perfect practice world
print(' '.join(sorted(set(input().split()))))
11、编写一个程序，该程序接受用逗号分隔的 4 位二进制数字序列作为输入，然后检查它们是否可被 5 整除。被 5 整除的数字将以逗号分隔的顺序打印。
示例 输入：0100,0011,1010,1001 输出：1010
print(','.join([x for x in input().split(',') if not int(x,2)%5]))
12、编写一个程序，查找所有介于 1000 和 3000 之间的整数（包括两者），以使整数的每个数字均为偶数。获得的整数应以逗号分隔的顺序打印在一行上。
value = []
for i in range(1000,3001):
for j in str(i):
if int(j)%2:
break
else:
value.append(str(i))
print(','.join(value))
# 方法二
print(','.join([str(i) for i in range(1000,3001) if not (i//1000%2 or i//100%10%2 or i//10%100%2 or i%10%2)]))
13、编写一个接受句子并计算字母和数字数量的程序。
示例 输入：hello world！123 ，输出：字母 10 数字 3
s = input()
n = c = 0
for i in s:
if i.isdigit(): n += 1
if i.isalpha(): c += 1
print(f"字母 {c} 数字 {n}")
14、编写一个接受句子的程序，并计算大写字母和小写字母的数量。
示例 输入：Hello world！，输出：UPPER CASE 1 LOWER CASE 9
s = input()
u = l = 0
for i in s:
if i.isupper(): u += 1
if i.islower(): l += 1
print(f"UPPER CASE {u} LOWER CASE {l}")
15、编写一个程序，以给定的数字作为 a 的值来计算 a + aa + aaa + aaaa 的值。
示例 输入：9 ，输出：11106
a = input()
print(int(a)+int(a+a)+int(a+a+a)+int(a+a+a+a))
16、输入由逗号分隔的数字序列，将序列中的偶数变成它的平方，奇数变成它的立方输出。
示例 输入：1,2,3,4,5 ，输出：1,4,27,16,125
print(','.join([str(x**3) if x%2 else str(x**2) for x in map(int,input().split(','))]))
17、编写一个程序，该程序根据控制台输入的交易日志来计算银行帐户的净额。事务日志格式如下所示：D 100 W 200 D 表示存款，W 表示提款。
示例 输入：D 300 D 300 W 200 D 100 然后，输出应为：500
netAmount = 0
while values:=input().split():
for i in range(0,len(values),2):
operate = values[i]
data = int(values[i+1])
if operate == 'D':
netAmount += data
else:
operate == 'W'
netAmount -= data
print(netAmount)
18、编写程序以检查用户输入的密码是否有效。
密码的标准：
必须包含大小写字母、数字和[$＃@] 中的至少1个字符，
密码最小长度：6
密码最大长度：12
您的程序应接受逗号分隔的密码序列，将符合条件的密码将被打印，每个密码之间用逗号分隔。示例 输入：ABd1234 @ 1,a F1＃,2w3E *,2We3345 输出：ABd1234 @ 1
import re
secrets = input().split(',')
pattern = re.compile('^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[$＃@]).{6,12}$')
print(','.join([psw for psw in secrets if pattern.match(psw)]))
# 也可以
def checkpass():
sec = []
secrets = input().split(',')
for pw in secrets:
d = c = u = f = False
if 5<len(pw)<13:
for c in pw:
if c in ['$','#','@' ]: f = True
elif c.isdigit(): d = True
elif c.islower(): c = True
elif c.isupper(): u = True
if f and d and c and u:sec.append(pw)
return sec
print(','.join(checkpass()))
19、您需要编写一个程序来按升序对（名称，年龄，身高）元组进行排序，其中名称是字符串，年龄和身高是数字。元组由控制台输入。排序标准为：1：根据名称排序；2：然后根据年龄排序；3：然后按分数排序。优先级是名称>年龄>得分。
示例 输入：
Tom,19,80
John,20,90
Jony,17,91
Jony,17,93
Json,21,85
输出：[[ John”，“ 20”，“ 90”），（“ Jony”，“ 17”，“ 91”），（“ Jony”，“ 17”，“ 93”），（“ Json”，“ 21”，“ 85’），（‘Tom’，‘19’，‘80’）]
from operator import itemgetter
l = []
while s := input():
l.append(tuple(s.split(',')))
print(sorted(l,key=itemgetter(0,1,2)))
# 也可以
print(sorted(l,key=lambda x: x[2]))
print(sorted(l,key=lambda x: x[1]))
print(sorted(l,key=lambda x: x[0]))
operator.itemgetter
operator 模块提供的 itemgetter 函数用于获取对象的指定维的数据，参数为一些序号。
a = [1,2,3]
>>> b=operator.itemgetter(1) //定义函数b，获取对象的第1个域的值
>>> b(a)
2
>>> b=operator.itemgetter(1,0) //定义函数b，获取对象的第1个域和第0个的值
>>> b(a)
(2, 1)
注意，operator.itemgetter 函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。
sorted 函数用来排序，sorted(iterable[, cmp[, key[, reverse]]])
其中key的参数为一个函数或者lambda函数。所以 itemgetter 可以用来当 key 的参数。
a = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=operator.itemgetter(1,2)) # 根据第二个域和第三个域进行排序
20、使用生成器定义一个类，该生成器可以在给定范围 0 和 n 之间迭代被 7 整除的数字。
def num(n):
for i in range(n+1):
if not i%7:yield i
for i in num(100):
print(i,end=' ')
21、机器人从原点（0,0）开始在平面上移动。机器人可以按照给定的步骤向上，下，左和右移动。机器人运动的轨迹如下所示：上 5 下 3 左 3 右 2¡方向后的数字为步长。请编写一个程序，以计算一系列移动和原始点之后与当前位置的距离。如果距离是浮点数，则只需打印最接近的整数即可。
示例 输入：UP 5 DOWN 3 LEFT 3 RIGHT 2 输出：2
import math
pos = [0,0]
while s := input():
move = s.split()
direction = move[0]
step = int(move[1])
if direction == 'UP':
pos[0] += step
elif direction == 'DOWN':
pos[0] -= step
elif direction == 'LEFT':
pos[1] -= step
elif direction == 'RIGHT':
pos[1] += step
print(int(round(math.sqrt(pos[1]**2+pos[0]**2))))
22、编写一个程序来计算输入中词的频率。在按字母数字顺序对键进行排序后，输出。
示例 输入：New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.
输出：2:2 3.:1 3?:1 New:1 Python:5 Read:1 and:1 between:1 choosing:1 or:2 to:1
d = {}
words = input().split()
# words_set = set(words)
# for w in words_set:
# d[w] = words.count(w)
for w in words:
# if d.get(w,-1)==-1:
if w not in d:
d[w] = 1
else:
d[w] += 1
keys = sorted(d)
d = {key:d[key] for key in keys}
for w in d:
print(f'{w}:{d[w]}',end=' ')
print()
23、Python 每个内置函数都有一个内置文档。请编写程序为您自己的功能添加文档提示。
def square(num):
'''
返回输入数字的平方值。
输入的数字必须是整数。
返回数字** 2 '''
return num**2
print(square.__doc__)
24、定义一个类，该类具有一个类参数并且具有相同的实例参数。
class Person:
name = 'Person' #定义类参数 name
def __init__(self,name=None):
self.name = name # name是实例参数
geoffrey = Person('Geoffrey')
print(f'{Person.name} 名称为 {geoffrey.name}')
nico = Person()
nico.name = '尼克'
print(f'{Person.name} 名称为 {nico.name}')
25、编写一个程序，使用 map() 和 filter() 组成一个列表，该列表的元素为[1,2,3,4,5,6,7,8,9,10]中的偶数平方。
l = [1,2,3,4,5,6,7,8,9,10]
print([x*x for x in l if not x%2])
print(list(map(lambda x:x*x,filter(lambda x:x%2==0,l))))
26、定义一个名为 American的类，该类具有一个称为 printNationality 的静态方法。
提示：使用@staticmethod装饰器定义类的静态方法。
解决方案
类 American（object）：
@ staticmethod
def printNationality（）：
print（“ America”）
anAmerican = American（）
anAmerican。printNationality（）
美国。printNationality（）
51、定义一个名为American的类及其子类NewYorker。
提示：
使用类Subclass（ParentClass）定义一个子类。
解决方案：
American类（对象）：
通过
NewYorker类（美国）：
通过
anAmerican = American（）
aNewYorker = NewYorker（）
打印（anAmerican）
打印（aNewYorker）
52、定义一个名为Circle的类，该类可以由半径构造。Circle类具有一种可以计算面积的方法。
提示：
使用def methodName（self）定义一个方法。
解决方案：
类 Circle（object）：
def init（self，r）：
self。半径 = r
def 区域（自我）：
返回 自我。半径** 2 * 3.14
aCircle = Circle（2）
打印 aCircle。区域（个）
53、定义一个名为Rectangle的类，该类可以通过长度和宽度来构造。Rectangle类具有可以计算面积的方法。
提示：
使用def methodName（self）定义一个方法。
解决方案：
class Rectangle（对象）：
def __init __（self，l，w）：
self。长度 = l
self。宽度 = w
def 区域（自我）：
返回 自我。长度*自我。宽度
aRectangle位于 = 矩形（2，10）
打印（aRectangle位于。区域（））
54、定义一个名为Shape的类及其子类Square。Square类具有一个init函数，该函数以长度作为参数。这两个类都有一个Area函数，该函数可以打印Shape的区域默认为0的形状的区域。
提示：
要覆盖超类中的方法，我们可以在超类中定义一个具有相同名称的方法。
解决方案：
类 Shape（object）：
def init（self）：
pass
def 区域（self）：
返回 0
正方形（形状）类：
def init（self，l）：
形状。init（自我）
自我。长度 = l
def 区域（自我）：
返回 自我。长度*自我。长度
aSquare = 广场（3）
打印（aSquare。区域（））
55、请引发RuntimeError异常。
提示：
使用raise（）引发异常。
解决方案：
引发 RuntimeError（‘出了点问题’）
56、编写一个函数以计算5/0并使用try / except捕获异常。
提示：
使用try / except捕获异常。
解决方案：
DEF 抛出（）：
返回 5 / 0
试试：
throws（）
除 ZeroDivisionError外：
print（“除以零！”）
除 Exception外，err：
print（‘捕获到一个异常’）
最后：
print（‘在finally块中进行清理’）
57、定义一个自定义异常类，该类将字符串消息作为属性。
提示：
要定义自定义异常，我们需要定义一个从Exception继承的类。
解决方案：
class MyError（Exception）：
“”“我自己的异常类
属性：
msg-错误
“”的说明
def __init__（self，msg）：
self。味精 = 味精
错误 = MyError（“出了点问题”）
58、假设我们有一些“ [email protected] ”格式的电子邮件地址，请编写程序以打印给定电子邮件地址的用户名。用户名和公司名都仅由字母组成。
示例：如果将以下电子邮件地址作为该程序的输入：
然后，程序的输出应为：
约翰
如果将输入数据提供给问题，则应假定它是控制台输入。
提示：
使用\ w匹配字母。
解决方案：
import re
emailAddress = raw_input（）
pat2 = “（\ w +）@（（\ w + \。）+（com））”
r2 = re。匹配（PAT2，EMAILADDRESS）
打印（R2。组（1））
59、假设我们有一些“ [email protected] ”格式的电子邮件地址，请编写程序以打印给定电子邮件地址的公司名称。用户名和公司名都仅由字母组成。
示例：如果将以下电子邮件地址作为该程序的输入：
然后，程序的输出应为：
谷歌
如果将输入数据提供给问题，则应假定它是控制台输入。
提示：
使用\ w匹配字母。
解决方案：
import re
emailAddress = raw_input（）
pat2 = “（\ w +）@（\ w +）\。（com）”
r2 = re。匹配（PAT2，EMAILADDRESS）
打印（R2。组（2））
60、编写一个程序，该程序接受由空格分隔的单词序列作为输入，以仅打印由数字组成的单词。
示例：如果给出以下单词作为程序输入：
2只猫和3只狗。
然后，程序的输出应为：
[‘2’，‘3’]
如果将输入数据提供给问题，则应假定它是控制台输入。
提示：
使用re.findall（）使用正则表达式查找所有子字符串。
解决方案：
进口 重新
小号 = 的raw_input（）
打印（重。的findall（“\ d +” ，š））
61、打印一个unicode字符串“ hello world”。
提示：
使用u’strings’格式定义unicode字符串。
解决方案：
unicodeString = u“你好，世界！”
打印（unicodeString）
62、编写程序以读取ASCII字符串并将其转换为utf-8编码的unicode字符串。
提示：
使用unicode（）函数进行转换。
解决方案：
s = 输入（）
u = Unicode（s，“ utf-8”）
打印（u）
63、编写特殊注释以指示python源代码文件位于unicode中。
提示：
解决方案：
＃--编码：utf-8--
＃----------------------------------------＃
64、编写一个程序，以控制台输入给定的n输入来计算1/2 + 2/3 + 3/4 + … + n / n + 1（n> 0）。
示例：如果将以下n作为程序的输入：
5
然后，程序的输出应为：
3.55
如果将输入数据提供给问题，则应假定它是控制台输入。
提示：使用float（）将整数转换为float
解决方案：
n = int（input（））
sum = 0.0
for i in range（1，n + 1）：
sum + = float（float（i）/（i + 1））
print（sum）
65、编写程序进行计算：
当n> 0且f（0）= 1时f（n）= f（n-1）+100
通过控制台输入给定的n（n> 0）。
示例：如果将以下n作为程序的输入：
5
然后，程序的输出应为：
500
如果将输入数据提供给问题，则应假定它是控制台输入。
提示：我们可以在Python中定义递归函数。
解决方案：
def f（n）：
如果 n == 0：
返回 0
else：
返回 f（n - 1）+ 100
n = int（输入（））
打印（f（n））
65、斐波那契数列是根据以下公式计算的：
如果n = 0则f（n）= 0如果n = 1则f（n）= 1如果n> 1则f（n-1）+ f（n-2）
请编写一个程序，以控制台输入给定的n个输入来计算f（n）的值。
示例：如果将以下n作为程序的输入：
7
然后，程序的输出应为：
13
如果将输入数据提供给问题，则应假定它是控制台输入。
提示：我们可以在Python中定义递归函数。
解决方案：
def f（n）：
如果 n == 0：返回 0
elif n == 1：返回 1
else：返回 f（n - 1）+ f（n - 2）
n = int（输入（））
打印（f（n））
67、斐波那契数列是根据以下公式计算的：
如果n = 0则f（n）= 0如果n = 1则f（n）= 1如果n> 1则f（n-1）+ f（n-2）
请编写一个使用列表推导的程序，以控制台输入给定的n输入以逗号分隔的形式打印斐波那契数列。
示例：如果将以下n作为程序的输入：
7
然后，程序的输出应为：
0,1,1,2,3,5,8,13
提示：我们可以在Python中定义递归函数。使用列表推导从现有列表生成列表。使用string.join（）连接字符串列表。
如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
def f（n）：
如果 n == 0：返回 0
elif n == 1：返回 1
else：返回 f（n - 1）+ f（n - 2）
n = int（输入（））
值 = [ str（f（x（））对于 x 在 范围（0，n + 1）中]]
print（“，”。join（值））
68、当控制台输入n时，请使用生成器编写一个程序，以逗号分隔的形式打印0到n之间的偶数。
示例：如果将以下n作为程序的输入：
10
然后，程序的输出应为：
0,2,4,6,8,10
提示：使用yield在生成器中产生下一个值。
如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
def EvenGenerator（n）：
i = 0
而 i <= n：
如果 i ％2 == 0：
产生 i
i + = 1
Ñ = INT（输入（））
的值 = []
为 我 在 EvenGenerator（Ñ）：
值。追加（str（i））
打印（“，”。联接（值））
69、当控制台输入n时，请使用生成器编写一个程序，以逗号分隔的形式打印可以在0和n之间被5和7整除的数字。
示例：如果将以下n作为程序的输入：
100
然后，程序的输出应为：
0,35,70
提示：使用yield在生成器中产生下一个值。
如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
def NumGenerator（n）：
对于 i 在 范围（n + 1）中：
如果 i ％5 == 0 和 i ％7 == 0：
产生 i
Ñ = INT（输入（））
的值 = []
为 我 在 NumGenerator（Ñ）：
值。追加（str（i））
打印（“，”。联接（值））
70、请编写assert语句以验证列表[2,4,6,8]中的每个数字都是偶数。
提示：使用“声明表达式”进行断言。
解决方案：
李 = [ 2，4，6，8 ]
为 我 在 李：
断言 我％2 == 0
71、请编写一个从控制台接受基本数学表达式的程序，并打印评估结果。
示例：如果将以下字符串作为程序的输入给出：
35 + 3
然后，程序的输出应为：
38
提示：使用eval（）评估表达式。
解决方案：
表达式 = raw_input（）
打印（eval（表达式））
72、请编写一个二进制搜索功能，该功能可以搜索已排序列表中的项目。该函数应返回列表中要搜索的元素的索引。
提示：使用if / elif处理条件。
解决方案：
进口 数学
DEF bin_search（里，元素）：
底部 = 0
顶部 = len个（李）- 1个
索引 = - 1
，而 顶> =底部 和 索引== - 1：
中期 = INT（数学。地板（（顶部+底部）/ 2.0））
if li [ mid] ==元件：
索引 = 中间
的elif 利[中间] >元素：
顶 = 中期- 1
否则：
底部 = 中间+ 1
回报 指数
李= [ 2，5，7，9，11，17，222 ]
打印（bin_search（李，11））
打印（bin_search（李，12））
73、请编写一个二进制搜索功能，该功能可以搜索已排序列表中的项目。该函数应返回列表中要搜索的元素的索引。
提示：使用if / elif处理条件。
解决方案：
进口 数学
DEF bin_search（里，元素）：
底部 = 0
顶部 = len个（李）- 1个
索引 = - 1
，而 顶> =底部 和 索引== - 1：
中期 = INT（数学。地板（（顶部+底部）/ 2.0））
if li [ mid] ==元件：
索引 = 中间
的elif 利[中间] >元素：
顶 = 中期- 1
否则：
底部 = 中间+ 1
回报 指数
李= [ 2，5，7，9，11，17，222 ]
打印（bin_search（李，11））
打印（bin_search（李，12））
74、请使用Python数学模块生成一个随机浮点数，其值在10到100之间。
提示：使用random.random（）在[0,1]中生成随机浮点数。
解决方案：
进口 随机
打印（随机，随机（）* 100）
75、请使用Python数学模块生成一个随机浮点数，其值在5到95之间。
提示：使用random.random（）在[0,1]中生成随机浮点数。
解决方案：
进口 随机
打印（随机，随机（）* 100 - 5）
76、请使用随机模块和列表推导编写一个程序，以输出介于0到10之间（含0和10）的随机偶数。
提示：使用random.choice（）对列表中的随机元素进行操作。
解决方案：
导入 随机
打印（随机。选择（[我 为 我 在 范围（11），如果 我％2 == 0））
77、请编写一个程序以输出一个随机数，使用随机模块和列表推导，该随机数可被5和7整除（介于0和10之间，包括0和10）。
提示：使用random.choice（）对列表中的随机元素进行操作。
解决方案：
导入 随机
打印（随机。选择（[如果i ％5 == 0和i ％7 == 0 [[ i for i 在 范围（201）中）]]
78、请编写程序以生成包含5个随机数（介于100和200之间，包括100和200）的列表。
提示：使用random.sample（）生成随机值列表。
解决方案：
导入 随机
打印（随机。样本（范围（100），5））
79、请编写一个程序以随机生成一个列表，该列表包含100至200之间（含两端）的5个偶数。
提示：使用random.sample（）生成随机值列表。
解决方案：
导入 随机
打印（随机。样品（[我 为 我 在 范围（100，201），如果 我％2 == 0 ]，5））
80、请编写一个程序以随机生成一个包含5个数字的列表，这些数字可以被5和7整除，且介于1和1000之间（含1和1000）。
提示：使用random.sample（）生成随机值列表。
解决方案：
导入 随机
打印（随机。样品（[我 为 我 在 范围（1，1001），如果 我％5 == 0 和 我％7 == 0 ]，5））
81、请编写一个程序以随机打印7到15之间的一个整数。
提示：使用random.randrange（）到给定范围内的随机整数。
解决方案：
导入 随机
打印（随机。randrange（7，16））
82、请编写一个程序来压缩和解压缩字符串“ hello world！hello world！hello world！hello world！”。
提示：使用zlib.compress（）和zlib.decompress（）压缩和解压缩字符串。
解决方案：
import zlib
s = b’hello world！hello world！hello world！hello world！’
t = zlib。压缩（小号）
打印（吨）
打印（zlib的。解压缩（吨））
83、请编写程序以打印“ 1 + 1”的执行运行时间100次。
提示：使用timeit（）函数来测量运行时间。
解决方案：
从 timeit 进口 定时器
吨 = 定时器（“对于i在范围（100）：1 + 1” ）
的打印（吨。timeit（））
84、请编写一个程序以随机播放并打印列表[3,6,7,8]。
提示：使用shuffle（）函数可对列表进行随机播放。
解决方案：
从 随机 导入 洗牌
利 = [ 3，6，7，8 ]
洗牌（李）
打印（李）
85、请编写一个程序以随机播放并打印列表[3,6,7,8]。
提示：使用shuffle（）函数可对列表进行随机播放。
解决方案：
从 随机 导入 洗牌
利 = [ 3，6，7，8 ]
洗牌（李）
打印（李）
86、请编写一个程序以生成所有句子，其中主语位于[“ I”，“ You”]中，动词位于[“ Play”，“ Love”]中，而宾语位于[“ Hockey”，“ Football”]中。
提示：使用list [index]表示法从列表中获取元素。
解决方案：
科目= [ “我”，“你” ]
动词= [ “玩”，“爱” ]
对象= [ “曲棍球”，“足球” ]
为 我 的 范围（len个（学科））：
用于 Ĵ 在 范围（LEN（动词））：
用于 ķ 在 范围（len个（对象））：
句子 = “％s％s％s。” ％（主语[ i ]，动词[ j ]，宾语[ k ]）
打印（句子）
87、请删除[5,6,77,45,22,12,24]中的删除偶数后编写程序以打印列表。
提示：使用列表推导从列表中删除一堆元素。
解决方案：
li = [5,6,77,45,22,12,24]
li = [x for x in li if x%2!=0]
print(li)
88、通过使用列表理解，请编写一个程序以删除在[12,24,35,70,88,120,155]中可被5和7整除的删除数字后打印列表。
提示：使用列表推导从列表中删除一堆元素。
解决方案：
li = [12,24,35,70,88,120,155]
li = [x for x in li if x%5!=0 and x%7!=0]
print(li)
89、通过使用列表理解，请编写一个程序以删除[12,24,35,70,88,120,155]中的第0、2、4、6个数字，然后打印列表。
提示：使用列表推导从列表中删除一堆元素。使用enumerate（）获取（索引，值）元组。
解决方案：
李 = [ 12，24，35，70，88，120，155 ]
里 = [ X 为（我，X）在 枚举（李）如果 我％2 ！= 0 ]
打印（李）
90、通过使用列表理解，请编写一个程序，生成一个3 5 8 3D数组，每个元素为0。
提示：使用列表推导来创建数组。
解决方案：
array = [[ [0 for col in range(8)] for col in range(5)] for row in range(3)]
print(array)
91、通过使用列表理解，请编写一个程序来删除[12,24,35,70,88,120,155]中的第0、4、5个数字，然后打印列表。
提示：使用列表推导从列表中删除一堆元素。使用enumerate（）获取（索引，值）元组。
解决方案：
李 = [ 12，24，35，70，88，120，155 ]
里 = [ X 为（我，X）在 枚举（李）如果 我 不 在（0，4，5）]
打印（李）
92、通过使用列表理解，请在删除[12,24,35,24,88,120,155]中的值24后编写程序以打印列表。
提示：使用列表的remove方法删除一个值。
解决方案：
李 = [ 12，24，35，24，88，120，155 ]
里 = [ X 为 X 在 里 如果 X ！= 24 ]
打印（李）
93、用两个给定的列表[1,3,6,78,35,55]和[12,24,35,24,88,120,155]，编写一个程序来制作一个列表，其元素是上述给定列表的交集。
提示：使用set（）和“＆=”进行交集操作。
解决方案：
SET1 =组（[ 1，3，6，78，35，55 ]）
SET2 =组（[ 12，24，35，24，88，120，155 ]）
SET1＆= SET2
李=列表（SET1）
打印（li）
94、使用给定的列表[12,24,35,24,88,120,155,88,120,155]，编写一个程序，在删除所有保留原始顺序的重复值之后，打印此列表。
提示：使用set（）可以存储许多没有重复的值。
解决方案：
DEF removeDuplicate（李）：
newli = []
看出 = 集（）
为 项目 在 李：
如果 项 不是 在 看到：
看到。添加（项目）
newli。追加（项目）
返回 newli
李= [ 12，24，35，24，88，120，155，88，120，155 ]
打印（removeDuplicate（李））
95、定义一个类Person及其两个子类：Male和Female。所有类都有一个方法“ getGender”，可以为“男”类打印“男”，为“女”打印“女”。
提示：使用Subclass（Parentclass）定义子类。
解决方案：
类 Person（对象）：
def getGender（self）：
返回 “未知”
类 Male（Person）：
def getGender（self）：
返回 “ Male”
类 女（Person）：
def getGender（self）：
返回 “女”
aMale = 男（）
aFemale = 女（）
打印（aMale。getGender（））
打印（aFemale。getGender（））
96、请编写一个程序，该程序对控制台输入的字符串中的每个字符的数量进行计数和打印。
示例：如果将以下字符串作为程序的输入给出：
abcdefgabc
然后，程序的输出应为：
a，2 c，2 b，2 e，1 d，1 g，1 f，1
提示：使用dict来存储键/值对。使用dict.get（）方法查找具有默认值的键。
解决方案：
DIC = {}
小号=的raw_input（）
为 小号 在 小号：
DIC [小号] = DIC。得到（小号，0）+ 1张
打印（’ \ n '。加入（[ '％S，％s’的 ％（ķ，v）为 ķ，v 在 DIC。项目（）））
97、请编写一个程序，该程序从控制台接收一个字符串，然后以相反的顺序打印它。
示例：如果将以下字符串作为程序的输入给出：
投票给先生
然后，程序的输出应为：
里斯·埃托夫·埃西尔
提示：使用list [::-1]以相反的顺序迭代列表。
解决方案：
s = raw_input（）
s = s [:: - 1 ]
打印（s）
98、请编写一个程序，该程序从控制台接受一个字符串，并打印具有偶数索引的字符。
示例：如果将以下字符串作为程序的输入给出：
H1e2l3l4o5w6o7r8l9d
然后，程序的输出应为：
你好，世界
提示：使用list [:: 2]通过步骤2迭代列表。
解决方案：
s = raw_input（）
s = s [:: 2 ]
打印（s）
99、请编写一个打印所有[1,2,3]排列的程序
提示：使用itertools.permutations（）获取列表的排列。
解决方案：
进口 itertools
打印（列表（itertools。置换（[ 1，2，3 ]）））
100、编写一个程序解决经典的中国古代难题：我们在农场的鸡和兔中数出35头和94腿。我们有多少只兔子和几只鸡？
提示：使用for循环迭代所有可能的解决方案。
解决方案：
高清 解决（numheads，numlegs）：
NS = ‘！无解’
对于 我 在 范围（numheads + 1）：
Ĵ = numheads -我
如果 2 *我+ 4 * Ĵ == numlegs：
返回 我，Ĵ
返回 NS，NS
numheads = 35
numlegs = 94个
解决方案= solve（numheads，numlegs）
打印（solutions）