1.等级说明
1级初学者
初学者是指刚刚完成Python入门课程的人。他可以使用1或2个Python类或函数解决一些问题。通常，答案可以直接在教科书中找到。
2级中级
中级是指刚刚学习过Python，但已经具有相对较强的编程背景的人。他应该能够解决可能涉及3或3个Python类或函数的问题。答案不能直接在教科书中找到。
3级高级。
他应该使用Python通过更丰富的库函数，数据结构和算法来解决更复杂的问题。他应该使用几种Python标准软件包和高级技术来解决该问题。
2.问题模板
问题提示解决方案
3.问题
问题1
1级
问题：编写一个程序，查找所有此类数字，它们可以被7整除，但不能是5的倍数，介于2000和3200之间（均包括在内）。获得的数字应以逗号分隔的顺序打印在一行上。
提示：考虑使用范围（＃begin，＃end）方法
解决方案：
升= []
为 我 在 范围（2000，3201）：
如果（我％7 == 0）和（我％5 =！0）：
升。追加（str（i））
打印（'，'。join（l））
问题2
1级
问题：编写一个程序，可以计算给定数字的阶乘。结果应以逗号分隔的顺序打印在一行上。假设将以下输入提供给程序：8然后，输出应为：40320
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
def fact（x）：
如果 x == 0：
返回 1
返回 x * fact（x - 1）
x = int（输入（））
打印（事实（x））
问题3
1级
问题：使用给定的整数n，编写程序以生成包含（i，i * i）的字典，该字典的值应为1到n之间的整数（都包括在内）。然后程序应打印字典。假设将以下输入提供给程序：8然后，输出应为：{1：1、2：4、3：9、4：16、5：25、6：36、7：49、8：64 }
提示：如果将输入数据提供给问题，则应假定它是控制台输入。考虑使用dict（）
解决方案：
n = int（输入（））
d =字典（）
对于 i 在 范围（1，n + 1）中：
d [ i ] = i * i
打印（d）
问题4
1级
问题：编写一个程序，该程序从控制台接受一系列逗号分隔的数字，并生成包含每个数字的列表和元组。假设将以下输入提供给程序：34,67,55,33,12,98然后，输出应为：['34'，'67'，'55'，'33'，'12'，' 98']（“ 34”，“ 67”，“ 55”，“ 33”，“ 12”，“ 98”）
提示：如果将输入数据提供给问题，则应假定它是控制台输入。tuple（）方法可以将列表转换为元组
解决方案：
值=输入（）
l =值。split（“，”）
t =元组（l）
打印（l）
打印（t）
问题5
1级
问题：定义一个至少具有两个方法的类：getString：从控制台输入中获取字符串printString：以大写形式打印该字符串。还请包括简单的测试功能来测试类方法。
提示：使用init方法构造一些参数
解决方案：
类 InputOutString（object）：
def __init__（self）：
self。s = “”
def getString（self）：
self。s = 输入（）
高清 PRINTSTRING（个体经营）：
打印（自我。小号。上（））
strObj = InputOutString（）
strObj。getString（）
strObj。printString（）
问题6
2级
问题：编写一个程序，根据给定的公式计算并打印该值：Q = [（2 * C * D）/ H]的平方根以下是C和H的固定值：C为50。H为30 。D是变量，其值应以逗号分隔的顺序输入到程序中。示例假定给程序提供了以下逗号分隔的输入序列：100,150,180程序的输出应为：18,22,24
提示：如果接收到的输出为十进制形式，则应四舍五入至最接近的值（例如，如果接收到的输出为26.0，则应将其打印为26）。应假定为控制台输入。
解决方案：
进口 数学
Ç = 50
ħ = 30
值 = []
项= [ X 为 X 在 输入（）。分裂（''）]
为 d 中 的项目：
值。追加（STR（INT（圆形（数学。SQRT（2 * ç *浮子（d）/ ħ）））））
print（'，'。join（value））
问题7
2级
问题：编写一个程序，该程序将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]]
提示：注意：如果将输入数据提供给问题，则应假定它是以逗号分隔形式的控制台输入。
解决方案：
input_str = 输入（）
尺寸= [ INT（X）为 X 的 input_str。分裂（''）]
的rowNum =尺寸[ 0 ]
colNum =尺寸[ 1 ]
多重表 = [[ 0 为 山口 在 范围（colNum）]为 行 中 的范围（的rowNum）]
对于 行 中 的范围（的rowNum）：
用于 山口 在 范围（colNum）：
多重表[行] [山口] = 行*山口
打印（多列表）
问题8
2级
问题：编写一个程序，该程序接受以逗号分隔的单词序列作为输入，并在按字母顺序对单词进行排序后以逗号分隔的顺序打印这些单词。假设向程序提供了以下输入：Without，hello，bag，world然后，输出应为：bag，hello，without，world
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
项= [ X 为 X 在 输入（）。split（'，'））
项目。sort（）
print（'，'。join（项目））
问题9
2级
问题：编写一个程序，接受行的顺序作为输入，并在将句子中的所有字符都大写之后打印行。假定向程序提供了以下输入：Hello world Practice使完美，然后，输出应为：HELLO WORLD PRACTICE完美无缺
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
lines = []，
而 True：
s = input（），
如果 s：
lines。追加（小号。上（））
其他：
休息;
对于 句子 的 线路：
打印（句子）
问题10
2级
问题：编写一个程序，该程序接受一系列由空格分隔的单词作为输入，并在删除所有重复的单词并将其按字母数字顺序排序后打印这些单词。假定向程序提供了以下输入：hello world and实践再次使完美和hello world然后，输出应为：again and hello使完美实践的世界
提示：如果将输入数据提供给问题，则应假定它是控制台输入。我们使用set容器自动删除重复的数据，然后使用sorted（）对数据进行排序。
解决方案：
š = 输入（）
词语 = [字 为 字 在 小号。split（“”）]
print（“”。join（排序（列表（set（单词）））））
问题11
2级
问题：编写一个程序，该程序接受用逗号分隔的4位二进制数字序列作为输入，然后检查它们是否可被5整除。被5整除的数字将以逗号分隔的顺序打印。示例：0100,0011,1010,1001然后输出应为：1010注意：假设数据是由控制台输入的。
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
值 = []
项= [ X 为 X 在 输入（）。在项目中为p的split（'，'）]
：
intp = int（p，2），
如果不是intp ％5：
value。追加（p）
print（'，'。join（value））
问题12
2级
问题：编写一个程序，查找所有介于1000和3000之间的数字（包括两者），以使数字的每个数字均为偶数。获得的数字应以逗号分隔的顺序打印在一行上。
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
值 = []
为 我 在 范围（1000，3001：）
小号 = STR（我）
如果（INT（小号[ 0 ]） ％2 == 0）和（INT（小号[ 1 ]） ％2 == 0）和（int（s [ 2 ]）％2 == 0）和（int（s [ 3 ]）％2 == 0）：
值。追加（小号）
打印（“” 。联接（值））
问题13
2级
问题：编写一个接受句子并计算字母和数字数量的程序。假设将以下输入提供给程序：hello world！123然后，输出应为：字母10位3
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
s = 输入（）
d = {对于C in s的{ DIGITS“：0，” LETTERS“：0 }
：
if c。isdigit（）：
d [ “ DIGITS” ] + = 1 elif c。isalpha（）：
d [ “ LETTERS” ] + = 1 else：
通过打印（“ LETTERS”，d [ “ LETTERS”
]）
打印（“ DIGITS”，d [ “ DIGITS” ]）
问题14
2级
问题：编写一个接受句子的程序，并计算大写字母和小写字母的数量。假设向程序提供了以下输入：Hello world！然后，输出应为：UPPER CASE 1 LOWER CASE 9
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
s = input（）
d = {对于c in s的{大写“：0，”小写“：0 }
：
if c。isupper（）：
d [ “大写” ] + = 1 elif c。islower（）：
d [ “ LOWER CASE” ] + = 1 else：
通过打印（“ UPPER CASE”，d [
“大写” ]）
打印（“小写”，d [ “小写” ]）
问题15
2级
问题：编写一个程序，以给定的数字作为a的值来计算a + aa + aaa + aaaa的值。假设将以下输入提供给程序：9然后，输出应为：11106
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
a = 输入（）
n1 = int（“％s” ％ a）
n2 = int（“％s％s” ％（a，a））
n3 = int（“％s％s％s” ％（a，a，a））
n4 = int（“％s％s％s％s” ％（a，a，a，a））
打印（n1 + n2+ n3 + n4）
问题16
2级
问题：使用列表理解将列表中的每个奇数平方。该列表由逗号分隔的数字序列输入。假设将以下输入提供给程序：1,2,3,4,5,6,7,8,9然后，输出应为：1,3,5,7,9
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
值 = 输入（）
数 = [ X 为 X 中 的值。如果int（x）％2 ！= 0 ]
则分割（“，”）print（“，”。join（数字））
问题17
2级
问题：编写一个程序，该程序根据控制台输入的交易日志来计算银行帐户的净额。事务日志格式如下所示：D 100 W 200
D表示存款，W表示提款。假设将以下输入提供给程序：D 300 D 300 W 200 D 100然后，输出应为：500
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
netAmount = 0，
而 True：
s = input（），
如果 不是 s：
break
values = s。split（“”）
操作 = 值[ 0 ]
数量 = 整数（值[ 1 ]），
如果 操作== “ D”：
netAmount + =数量
elif 操作== “ W”：
netAmount- =其他数量
：
通过打印（netAmount）
问题18
3级
问题：网站要求用户输入用户名和密码进行注册。编写程序以检查用户输入的密码是否有效。以下是检查密码的标准：
[az]之间至少1个字母
[0-9]之间至少1个数字
[AZ]之间至少1个字母
[$＃@]中的至少1个字符
交易密码的最小长度：6
交易密码的最大长度：12您的程序应接受逗号分隔的密码序列，并将根据上述条件进行检查。符合条件的密码将被打印，每个密码之间用逗号分隔。示例如果将以下密码作为该程序的输入：ABd1234 @ 1，a F1＃，2w3E *，2We3345然后，该程序的输出应为：ABd1234 @ 1
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
进口 重
值 = []
项= [ X 为 X 在 输入（）。分裂（''）]
为 p 在 项：
如果 len个（p）< 6 或 len个（p）> 12：
继续
其他：
通
如果 不 重新。搜索（“ [az]”，p）：
继续
ELIF 不 重。搜索（“[0-9]” ，p）：
继续
ELIF 不 重。搜索（“[AZ]” ，p）：
继续
ELIF 不 重。搜索（“ [[$＃@]”，p）：
继续
elif re。搜索（“ \ s”，p）：
继续进行
其他操作：
传递
值。追加（p）
print（“，”。join（value））
问题19
3级
问题：您需要编写一个程序来按升序对（名称，年龄，身高）元组进行排序，其中名称是字符串，年龄和身高是数字。元组由控制台输入。排序标准为：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'）]
提示：如果将输入数据提供给问题，则应假定它是控制台输入。我们使用itemgetter启用多个排序键。
解决方案：从操作员导入itemgetter，attrgetter
l = []
，如果为 True：
s = input（）
， 否则返回 s：
break
l。追加（元组（小号。分裂（“” ）））
打印（排序（升，键= itemgetter（0，1，2）））
问题20
3级
问题：使用生成器定义一个类，该生成器可以在给定范围0和n之间迭代被7整除的数字。
提示：考虑使用量
解决方案：
DEF putNumbers（Ñ）：
我 = 0
而 我< Ñ：
Ĵ =我
我=我+ 1
如果 Ĵ ％7 == 0：
收率 Ĵ
对于 我 在 反向（100）：
打印（我）
问题21
3级
问题机器人从原点（0,0）开始在平面上移动。机器人可以按照给定的步骤向上，下，左和右移动。机器人运动的轨迹如下所示：上5下3左3右2¡方向后的数字为步长。请编写一个程序，以计算一系列移动和原始点之后与当前位置的距离。如果距离是浮点数，则只需打印最接近的整数即可。示例：如果将以下元组作为程序的输入给出：UP 5 DOWN 3 LEFT 3 RIGHT 2然后，程序的输出应为：2
提示：如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
进口 数学
POS = [ 0，0 ]
，而 真：
š = 输入（）
如果 不 š：
破
运动 = 小号。split（“”）
方向 = 运动[ 0 ]
步长 = int（运动[ 1 ]），
如果 direction == “ UP”：
pos [ 0 ]+ =步骤
Elif 方向== “ DOWN”：
pos [ 0 ] -=步骤
Elif 方向== “ LEFT”：
pos [ 1 ] -=步骤
Elif 方向== “ RIGHT”：
pos [ 1 ] + =步骤
else：
经过
打印（INT（圆形（数学。SQRT（POS [ 1 ] ** 2个+ POS [ 0 ] ** 2））））
问题22
3级
问题：编写一个程序来计算输入中单词的频率。在按字母数字顺序对键进行排序后，应输出输出。假设向程序提供了以下输入：Python的新手还是在Python 2和Python 3之间选择？读取Python 2或Python3。然后，输出应为：2：2 3.:1 3？：1新建：1 Python：5读取：1和：1之间：1之间的选择：1或：2至：1
提示如果将输入数据提供给问题，则应假定它是控制台输入。
解决方案：
FREQ = {} 在文本中的单词的＃频率
线 = 输入（）
为 字 中 线。split（）：
freq [ word ] = freq。得到（word，0）+ 1
词语 = 频率。键（）
字。排序（）
为 瓦特 在 字：
打印（“％S：％d” ％ （瓦特，频率[瓦特]））
问题23
1级
问题：写一种可以计算数字平方值的方法
提示：使用**运算符
解决方案：
def 平方（num）：
返回 num ** 2
打印（正方形（2））
打印（正方形（3））
问题24
1级
问题：
Python具有许多内置函数，如果您不知道如何使用它，则可以在线阅读文档或查找一些书籍。但是Python对于每个内置函数都有一个内置文档函数。
请编写程序以打印一些Python内置函数文档，例如abs（），int（），raw_input（）
并为您自己的功能添加文档提示：内置文档方法为doc
解决方案：
打印（ABS。__doc__）
打印（INT。__doc__）
打印（输入。__doc__）
def square（num）：
'''返回输入数字的平方值。
输入的数字必须是整数。 '''返回数字** 2
打印（正方形（2））
的打印（正方形。__doc__）
问题25
1级
问题：定义一个类，该类具有一个类参数并且具有相同的实例参数。
提示：定义实例参数，需要在init方法中添加它。
解决方案：
class Person：
＃定义类参数“ name”
name = “ Person”
def __init__（self，name = None）：
＃self.name是实例参数
self。名称 = 名称
杰弗里 = 人（“杰弗里”）
打印（“％S名称为％s” ％ （人。名，杰弗里。名））
nico = 人（）
nico。名称 = “尼科”
打印（“％S名称为％s” ％ （人。名，尼科。名））
问题26：
定义一个可以计算两个数字之和的函数。
提示：定义一个以两个数字作为参数的函数。您可以在函数中计算总和并返回值。
解决方案
高清 SumFunction（数字1，数字2）：
返回 数字1 +数字2
打印（SumFunction（1，2））
问题27
定义一个可以将整数转换为字符串并在控制台中打印的函数。
提示：
使用str（）将数字转换为字符串。
解决方案
def printValue（n）：
打印（str（n））
printValue（3）
问题28
定义一个可以将整数转换为字符串并在控制台中打印的函数。
提示：
使用str（）将数字转换为字符串。
解决方案
def printValue（n）：
打印（str（n））
printValue（3）
问题29
定义一个函数，该函数可以接收两个字符串形式的整数并计算它们的总和，然后在控制台中将其打印出来。
提示：
使用int（）将字符串转换为整数。
解决方案
def printValue（s1，s2）：
打印（int（s1）+ int（s2））
printValue（“ 3”，“ 4”）
问题30
定义一个函数，该函数可以接受两个字符串作为输入并将其连接起来，然后在控制台中将其打印出来。
提示：
使用+连接字符串
解决方案
def printValue（s1，s2）：
打印（s1 + s2）
printValue（“ 3”，“ 4”）＃34
第31章
定义一个函数，该函数可以接受两个字符串作为输入，并在控制台中打印最大长度的字符串。如果两个字符串的长度相同，则该函数应逐行打印所有字符串。
提示：
使用len（）函数获取字符串的长度
解决方案
def printValue（s1，s2）：
len1 = len（s1）
len2 = len（s2）
如果 len1 > len2：
打印（s1）
elif len2 > len1：
打印（s2）
否则：
打印（s1）
打印（s2）
printValue（“一个”，“三个”）
第32章
定义一个可以接受整数作为输入的函数，如果数字是偶数，则打印“它是偶数”，否则打印“它是奇数”。
提示：
使用％运算符检查数字是偶数还是奇数。
解决方案
def checkValue（n）：
如果 n ％2 == 0：
打印（“这是一个偶数”）
否则：
打印（“这是一个奇数”）
checkValue（7）
###提问33
定义 一个 函数 ，其 可以 打印 一个 字典 ，其中 所述 键 是 数字 之间 1 和 3（既 包括）和 所述 值 是 正方形 的 键。
提示：
使用 字典[关键] =价值 模式 ，以 把 进入 到 一个 字典。
使用 ** 操作 来 获得 权力 的 一个 数。
解决方案
` ` python
def printDict（）：
d = dict（）
d [ 1 ] = 1
d [ 2 ] = 2 ** 2
d 2 [ 3 ] = 3 ** 2
print（d）
printDict（）
第34章
定义一个可以打印字典的函数，其中键是1到20之间的数字（都包括在内），值是键的平方。
提示：
使用dict [key] = value模式将条目放入字典中。使用**运算符可获取数字的幂。使用range（）进行循环。
解决方案
DEF printDict（）：
d =字典（）
为 我 在 范围（1，21）：
d [我] =我** 2
打印（d）
printDict（）
第35章
定义一个可以生成字典的函数，其中键是1到20之间的数字（都包括在内），值是键的平方。该功能应仅打印值。
提示：
使用dict [key] = value模式将条目放入字典中。使用**运算符可获取数字的幂。使用range（）进行循环。使用keys（）迭代字典中的键。我们也可以使用item（）来获取键/值对。
解决方案
DEF printDict（）：
d =字典（）
为 我 在 范围（1，21）：
d [我] =我** 2
为（ķ，v）在 d。项目（）：
打印（v）
printDict（）
第36章
定义一个可以生成字典的函数，其中键是1到20之间的数字（都包括在内），值是键的平方。该功能应仅打印键。
提示：
使用dict [key] = value模式将条目放入字典中。使用**运算符可获取数字的幂。使用range（）进行循环。使用keys（）迭代字典中的键。我们也可以使用item（）来获取键/值对。
解决方案
DEF printDict（）：
d =字典（）
为 我 在 范围（1，21）：
d [我] =我** 2
为 ķ 在 d。键（）：
打印（k）
printDict（）
第37章
定义一个函数，该函数可以生成并打印一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。
提示：
使用**运算符可获取数字的幂。使用range（）进行循环。使用list.append（）将值添加到列表中。
解决方案
DEF 的printList（）：
李=列表（）
为 我 在 范围（1，21）：
利。附加（i ** 2）
打印（li）
printList（）
第38章
定义一个函数，该函数可以生成一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。然后，该功能需要打印列表中的前5个元素。
提示：
使用**运算符可获取数字的幂。使用range（）进行循环。使用list.append（）将值添加到列表中。使用[n1：n2]分割列表
解决方案
DEF 的printList（）：
李=列表（）
为 我 在 范围（1，21）：
利。追加（i ** 2）
打印（li [：5 ]）
printList（）
第39章
定义一个函数，该函数可以生成一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。然后，该功能需要打印列表中的最后5个元素。
提示：
使用**运算符可获取数字的幂。使用range（）进行循环。使用list.append（）将值添加到列表中。使用[n1：n2]分割列表
解决方案
DEF 的printList（）：
李=列表（）
为 我 在 范围（1，21）：
利。追加（我** 2）
打印（李[ - 5：]）
printList（）
第40章
定义一个函数，该函数可以生成一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。然后，该函数需要打印列表中前5个元素以外的所有值。
提示：
使用**运算符可获取数字的幂。使用range（）进行循环。使用list.append（）将值添加到列表中。使用[n1：n2]分割列表
解决方案
DEF 的printList（）：
李=列表（）
为 我 在 范围（1，21）：
利。追加（i ** 2）
打印 li [ 5：]
printList（）
第41章
定义一个函数，该函数可以生成并打印一个元组，其中值是介于1到20之间的数字的平方（均包括在内）。
提示：
使用**运算符可获取数字的幂。使用range（）进行循环。使用list.append（）将值添加到列表中。使用tuple（）从列表中获取一个元组。
解决方案
DEF printTuple（）：
李=列表（）
为 我 在 范围（1，21）：
利。追加（i ** 2）
打印（元组（li））
printTuple（）
第42章
使用给定的元组（1,2,3,4,5,6,7,8,9,10），编写一个程序以一行打印前半值，然后以一行打印后半值。
提示：
使用[n1：n2]表示法从元组中获取一个切片。
解决方案
TP =（1，2，3，4，5，6，7，8，9，10）
TP1 = TP [：5 ]
TP2 = TP [ 5：]
打印（TP1）
打印（TP2）
第43章
编写程序以生成并打印另一个在给定元组（1,2,3,4,5,6,7,8,9,10）中其值为偶数的元组。
提示：
使用“ for”来迭代元组使用tuple（）从列表中生成一个元组。
解决方案
TP =（1，2，3，4，5，6，7，8，9，10）
里=列表（）
为 我 在 TP：
如果 TP [我] ％2 == 0：
利。追加（tp [ i ]）
tp2 =元组（li）
打印（tp2）
第44章
编写一个接受字符串作为输入的程序，如果该字符串是“ yes”或“ YES”或“ Yes”，则打印“ Yes”，否则打印“ No”。
提示：
使用if语句判断条件。
解决方案
s = raw_input（）
如果 s == “是” 或 s == “是” 或 s == “是”：
打印 “是”
否则：
打印 “否”
第45章
编写一个程序，该程序可以使用过滤器功能过滤列表中的偶数。列表为：[1,2,3,4,5,6,7,8,9,10]。
提示：
使用filter（）过滤列表中的某些元素。使用lambda定义匿名函数。
解决方案
李 = [ 1，2，3，4，5，6，7，8，9，10 ]
evenNumbers = 过滤器（拉姆达 X：X ％2 == 0，李）
打印（evenNumbers）
第46章
编写一个程序，该程序可以map（）创建一个列表，该列表的元素是[1,2,3,4,5,6,7,8,9,10]中的元素的平方。
提示使用map（）生成列表。使用lambda定义匿名函数。
解决方案
李 = [ 1，2，3，4，5，6，7，8，9，10 ]
squaredNumbers = 地图（拉姆达 X：X ** 2，李）
打印（squaredNumbers）
第47章
编写一个程序，该程序可以map（）和filter（）组成一个列表，该列表的元素为[1,2,3,4,5,6,7,8,9,10]中的偶数平方。
提示使用map（）生成列表。使用filter（）过滤列表中的元素。使用lambda定义匿名函数。
解决方案
李 = [ 1，2，3，4，5，6，7，8，9，10 ]
evenNumbers = 地图（拉姆达 X：X ** 2，过滤器（拉姆达 X：X ％2 == 0，丽））
打印（evenNumbers）
第48章
编写一个程序，该程序可以使用filter（）创建一个列表，该列表的元素为1到20之间的偶数（均包括在内）。
提示：
使用filter（）过滤列表中的元素。使用lambda定义匿名函数。
解决方案
evenNumbers = 过滤器（拉姆达 X：X ％2 == 0，范围（1，21））
打印（evenNumbers）
第49章
编写一个程序，该程序可以map（）创建一个列表，该列表的元素为1到20之间的数字平方（均包括在内）。
提示使用map（）生成列表。使用lambda定义匿名函数。
解决方案
squaredNumbers = 地图（拉姆达 X：X ** 2，范围（1，21））
打印（squaredNumbers）
第50章
定义一个名为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））
第66章
斐波那契数列是根据以下公式计算的：
如果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）
更多精彩内容可以关注公众号：学习py最风sao的方式