| 1级 |
|
|
|
| 题： |
| 编写一个程序，查找所有可以被7整除但不是5的倍数的数字。 |
| 在2000到3200之间（均包括在内）。 |
| 所获得的数字应以逗号分隔的顺序打印在一行上。 |
|
|
| 提示： |
| 考虑使用范围（＃begin，＃end）方法 |
|
|
| 解： |
| l = [] |
| 对于范围内的i（2000，3201）： |
| 如果（i％7 == 0）和（i％5！= 0）： |
| l.append（str（i）） |
|
|
| 打印'，'。join（l） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题2 |
| 1级 |
|
|
| 题： |
| 编写一个程序，可以计算给定数字的阶乘。 |
| 结果应以逗号分隔的顺序打印在一行上。 |
| 假设将以下输入提供给程序： |
| 8 |
| 然后，输出应为： |
| 40320 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| def fact（x）： |
| 如果x == 0： |
| 返回1 |
| 返回x *事实（x-1） |
|
|
| x = int（raw_input（）） |
| 列印事实（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 = dict（） |
| 对于范围（1，n + 1）中的i： |
| d [i] = i * i |
|
|
| 打印d |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题4 |
| 1级 |
|
|
| 题： |
| 编写一个程序，该程序从控制台接受一个逗号分隔的数字序列，并生成一个列表和一个包含每个数字的元组。 |
| 假设将以下输入提供给程序：交流裙：753532316 |
| 34,67,55,33,12,98 |
| 然后，输出应为： |
| ['34'，'67'，'55'，'33'，'12'，'98'] |
| （“ 34”，“ 67”，“ 55”，“ 33”，“ 12”，“ 98”） |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
| tuple（）方法可以将列表转换为元组 |
|
|
| 解： |
| 值= raw_input（） |
| l = values.split（“，”） |
| t =元组（l） |
| 打印l |
| 打印t |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题5 |
| 1级 |
|
|
| 题： |
| 定义一个至少具有两个方法的类： |
| getString：从控制台输入获取字符串 |
| printString：以大写形式输出字符串。 |
| 还请包括简单的测试功能以测试类方法。 |
|
|
| 提示： |
| 使用__init__方法构造一些参数 |
|
|
| 解： |
| InputOutString（object）类： |
| def __init __（）： |
| self.s =“” |
|
|
| def getString（）： |
| self.s = raw_input（） |
|
|
| def printString（）： |
| 打印self.s.upper（） |
|
|
| 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）。 |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| ＃！/ usr / bin / env python |
| 导入数学 |
| c = 50 |
| h = 30 |
| 值= [] |
| items = [x代表raw_input（）。split（'，'）中的x] |
| 对于d个项目： |
| value.append（str（int（round（math.sqrt（2 * c * float（d）/ h））））） |
|
|
| 打印'，'。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 = raw_input（） |
| Dimensions = [input_str.split（'，'）中x的int（x）] |
| rowNum =尺寸[0] |
| colNum =尺寸[1] |
| multilist = [[0表示范围（colNum）的col]]表示范围（rowNum）的行] |
|
|
| 对于范围（rowNum）中的行： |
| 对于范围内的col（colNum）： |
| multilist [row] [col] = row * col |
|
|
| 打印多列表 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题8 |
| 2级 |
|
|
| 题： |
| 编写一个程序，该程序接受以逗号分隔的单词序列作为输入，并在按字母顺序对单词进行排序后以逗号分隔的顺序打印这些单词。 |
| 假设将以下输入提供给程序： |
| 没有，你好，袋，世界 |
| 然后，输出应为： |
| 袋，你好，没有，世界 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| items = [x代表raw_input（）。split（'，'）中的x] |
| items.sort（） |
| 打印'，'。join（项目） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题9 |
| 2级 |
|
|
| 问题： |
| 编写一个接受行序列作为输入的程序，并在将句子中的所有字符都大写之后打印行。 |
| 假设将以下输入提供给程序： |
| 你好，世界 |
| 实践使完美 |
| 然后，输出应为： |
| 你好，世界 |
| 实践完美 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| 行数= [] |
| 而True： |
| s = raw_input（） |
| 如果s： |
| lines.append（s.upper（）） |
| 其他： |
| 打破; |
|
|
| 对于以下句子： |
| 打印句子 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题10 |
| 2级 |
|
|
| 题： |
| 编写一个程序，该程序接受一系列由空格分隔的单词作为输入，并在删除所有重复的单词并将其按字母数字顺序排序后打印这些单词。 |
| 假设将以下输入提供给程序： |
| 你好世界，实践使世界变得完美，你好世界 |
| 然后，输出应为： |
| 再次，你好使完美实践世界 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
| 我们使用set容器自动删除重复的数据，然后使用sorted（）对数据进行排序。 |
|
|
| 解： |
| s = raw_input（） |
| 单词= [s.split（“”）中的单词对单词] |
| 打印“” .join（sorted（list（set（set（words）））） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题11 |
| 2级 |
|
|
| 题： |
| 编写一个程序，该程序接受以逗号分隔的4位二进制数字序列作为输入，然后检查它们是否可被5整除。被5整除的数字将以逗号分隔的顺序打印。 |
| 例： |
| 0100,0011,1010,1001 |
| 然后输出应为： |
| 1010 |
| 注意：假设数据是通过控制台输入的。 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| 值= [] |
| items = [x代表raw_input（）。split（'，'）中的x] |
| 对于p项： |
| intp = int（p，2） |
| 如果不是intp％5： |
| value.append（p） |
|
|
| 打印'，'。join（value） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题12 |
| 2级 |
|
|
| 题： |
| 编写一个程序，它将找到介于1000和3000之间的所有此类数字（均包括在内），以使该数字的每个数字均为偶数。 |
| 所获得的数字应以逗号分隔的顺序打印在一行上。 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| 值= [] |
| 对于范围在（1000，3001）中的i： |
| s = str（i） |
| if（int（s [0]）％2 == 0）和（int（s [1]）％2 == 0）和（int（s [2]）％2 == 0）和（int（s [3]）％2 == 0）： |
| values.append（s） |
| 打印“，”。join（值） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题13 |
| 2级 |
|
|
| 题： |
| 编写一个接受句子并计算字母和数字数量的程序。 |
| 假设将以下输入提供给程序： |
| 你好，世界！123 |
| 然后，输出应为： |
| 字母10 |
| 数字3 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| s = raw_input（） |
| d = {“数字”：0，“字母”：0} |
| 对于c in s： |
| 如果c.isdigit（）： |
| d [“ DIGITS”] + = 1 |
| elif c.isalpha（）： |
| d [“ LETTERS”] + = 1 |
| 其他： |
| 通过 |
| 打印“字母”，d [“字母”] |
| 打印“ DIGITS”，d [“ DIGITS”] |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题14 |
| 2级 |
|
|
| 题： |
| 编写一个接受句子的程序，并计算大写字母和小写字母的数量。 |
| 假设将以下输入提供给程序： |
| 你好，世界！ |
| 然后，输出应为： |
| 大写1 |
| 小写9 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| s = raw_input（） |
| d = {“大写”：0，“小写”：0} |
| 对于c in s： |
| 如果c.isupper（）： |
| d [“大写”] + = 1 |
| elif c.islower（）： |
| d [“小写”] + = 1 |
| 其他： |
| 通过 |
| 打印“大写”，d [“大写”] |
| 打印“小写”，d [“小写”] |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题15 |
| 2级 |
|
|
| 题： |
| 编写一个程序，以给定的数字作为a的值来计算a + aa + aaa + aaaa的值。 |
| 假设将以下输入提供给程序： |
| 9 |
| 然后，输出应为： |
| 11106 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| 一个= raw_input（） |
| 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 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| 值= raw_input（） |
| 数字= [如果int（x）％2！= 0，则x为values.split（“，”）中的x。 |
| 打印“，”。join（数字） |
| ＃----------------------------------------＃ |
|
|
| 问题17 |
| 2级 |
|
|
| 题： |
| 编写一个程序，该程序根据控制台输入的交易日志来计算银行帐户的净额。事务日志格式如下所示： |
| D 100 |
| 200号 |
|
|
| D表示存款，W表示提款。 |
| 假设将以下输入提供给程序： |
| D 300 |
| D 300 |
| 200号 |
| D 100 |
| 然后，输出应为： |
| 500 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| netAmount = 0 |
| 而True： |
| s = raw_input（） |
| 如果不是s： |
| 打破 |
| 值= s.split（“”） |
| 操作=值[0] |
| 数量= int（值[1]） |
| 如果operation ==“ D”： |
| netAmount + =金额 |
| elif operation ==“ W”： |
| netAmount- =金额 |
| 其他： |
| 通过 |
| 打印净额 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题18 |
| 3级 |
|
|
| 题： |
| 网站要求用户输入用户名和密码进行注册。编写程序以检查用户输入的密码的有效性。 |
| 以下是检查密码的标准： |
| 1. [az]之间至少1个字母 |
| 2. [0-9]之间至少1个数字 |
| 1. [AZ]之间至少1个字母 |
| 3. [$＃@]中的至少1个字符 |
| 4.最小交易密码长度：6 |
| 5.交易密码的最大长度：12 |
| 您的程序应接受一系列用逗号分隔的密码，并将根据上述条件进行检查。符合条件的密码将被打印，每个密码之间用逗号分隔。 |
| 例 |
| 如果输入以下密码作为程序输入： |
| ABd1234 @ 1，a F1＃，2w3E *，2We3345 |
| 然后，程序的输出应为： |
| ABd1234 @ 1 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解决方案： |
| 汇入 |
| 值= [] |
| items = [x代表raw_input（）。split（'，'）中的x] |
| 对于p项： |
| 如果len（p）<6或len（p）> 12： |
| 继续 |
| 其他： |
| 通过 |
| 如果不是re.search（“ [az]”，p）： |
| 继续 |
| 如果不是re.search（“ [0-9]”，p）： |
| 继续 |
| 如果不是re.search（“ [AZ]”，p）： |
| 继续 |
| Elif not re.search（“ [$＃@]”，p）： |
| 继续 |
| elif re.search（“ \ s”，p）： |
| 继续 |
| 其他： |
| 通过 |
| value.append（p） |
| 打印“，”。join（值） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题19 |
| 3级 |
|
|
| 题： |
| 您需要编写程序以升序对（名称，年龄，身高）元组进行排序，其中名称是字符串，年龄和身高是数字。元组由控制台输入。排序标准是： |
| 1：根据名称排序； |
| 2：然后根据年龄排序； |
| 3：然后按分数排序。 |
| 优先级是名称>年龄>得分。 |
| 如果给出以下元组作为程序的输入： |
| 汤姆19,80 |
| 约翰20,90 |
| 乔尼17,91 |
| 乔尼，17,93 |
| 杰森21,85 |
| 然后，程序的输出应为： |
| [（'John'，'20'，'90'），（'Jony'，'17'，'91'），（'Jony'，'17'，'93'），（'Json'，'21 '，'85'），（'Tom'，'19'，'80'）] |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
| 我们使用itemgetter启用多个排序键。 |
|
|
| 解决方案： |
| 从操作员导入itemgetter，attrgetter |
|
|
| l = [] |
| 而True： |
| s = raw_input（） |
| 如果不是s： |
| 打破 |
| l.append（tuple（s.split（“，”））） |
|
|
| 打印排序（l，key = itemgetter（0,1,2）） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题20 |
| 3级 |
|
|
| 题： |
| 用生成器定义一个类，该生成器可以在给定范围0和n之间迭代可以被7整除的数字。 |
|
|
| 提示： |
| 考虑使用量 |
|
|
| 解： |
| def putNumbers（n）： |
| 我= 0 |
| 而我<n： |
| j = i |
| i = i + 1 |
| 如果j％7 == 0： |
| 屈服j |
|
|
| 对于我反向（100）： |
| 打印我 |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题21 |
| 3级 |
|
|
| 问题： |
| 机器人从原始点（0,0）开始在平面中移动。机器人可以按照给定的步骤向上，下，左和右移动。机器人运动的轨迹如下所示： |
| 上5 |
| 下3 |
| 左3 |
| 右2 |
| ¡ |
| 方向后的数字为步长。请编写一个程序，以计算一系列移动和原始点之后与当前位置的距离。如果距离是浮点数，则只需打印最接近的整数。 |
| 例： |
| 如果给出以下元组作为程序的输入： |
| 上5 |
| 下3 |
| 左3 |
| 右2 |
| 然后，程序的输出应为： |
| 2 |
|
|
| 提示： |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| 导入数学 |
| pos = [0,0] |
| 而True： |
| s = raw_input（） |
| 如果不是s： |
| 打破 |
| 运动= s.split（“”） |
| 方向=运动[0] |
| 步长= int（运动[1]） |
| 如果direction ==“ UP”： |
| pos [0] + =步骤 |
| elif direction ==“ DOWN”： |
| pos [0]-=步骤 |
| elif direction ==“左”： |
| pos [1]-=步骤 |
| elif direction ==“ RIGHT”： |
| pos [1] + =步骤 |
| 其他： |
| 通过 |
|
|
| 打印int（round（math.sqrt（pos [1] ** 2 + pos [0] ** 2））） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题22 |
| 3级 |
|
|
| 题： |
| 编写程序以计算输入中单词的频率。在按字母数字顺序对键进行排序后，应输出输出。 |
| 假设将以下输入提供给程序： |
| 是Python的新手，还是在Python 2和Python 3之间选择？阅读Python 2或Python 3。 |
| 然后，输出应为： |
| 2：2 |
| 3 :: 1 |
| 3？：1 |
| 新增：1个 |
| 的Python：5 |
| 阅读：1 |
| 和：1 |
| 之间：1 |
| 选择：1 |
| 或：2 |
| 至：1 |
|
|
| 提示 |
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
| freq = {}＃文字中的词频 |
| 行= raw_input（） |
| 对于line.split（）中的单词： |
| freq [word] = freq.get（word，0）+1 |
|
|
| 单词= freq.keys（） |
| words.sort（） |
|
|
| 对于w而言： |
| 打印“％s：％d”％（w，freq [w]） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题23 |
| 1级 |
|
|
| 题： |
| 编写一种可以计算数字平方值的方法 |
|
|
| 提示： |
| 使用**运算符 |
|
|
| 解： |
| def平方（数字）： |
| 返回数字** 2 |
|
|
| 打印方块（2） |
| 打印方块（3） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题24 |
| 1级 |
|
|
| 题： |
| Python具有许多内置函数，如果您不知道如何使用它，则可以在线阅读文档或查找一些书籍。但是Python对于每个内置函数都有一个内置文档函数。 |
| 请编写程序以打印一些Python内置函数文档，例如abs（），int（），raw_input（） |
| 并为您自己的功能添加文档 |
|
|
| 提示： |
| 内置文档方法是__doc__ |
|
|
| 解： |
| 打印Abs .__ doc__ |
| 打印int .__ doc__ |
| 打印raw_input .__ doc__ |
|
|
| def平方（数字）： |
| '''返回输入数字的平方值。 |
|
|
| 输入的数字必须是整数。 |
| ''' |
| 返回数字** 2 |
|
|
| 打印方块（2） |
| 打印方块。__doc__ |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 问题25 |
| 1级 |
|
|
| 题： |
| 定义一个类，该类具有一个类参数并且具有相同的实例参数。 |
|
|
| 提示： |
| 定义实例参数，需要将其添加到__init__方法中 |
| 您可以使用构造参数初始化对象或稍后设置值 |
|
|
| 解： |
| 班级人员： |
| ＃定义类参数“名称” |
| 名称=“人” |
|
|
| def __init __（self，name = None）： |
| ＃self.name是实例参数 |
| self.name =名称 |
|
|
| 杰弗里= Person（“杰弗里”） |
| 打印“％s名称为％s”％（Person.name，jeffrey.name） |
|
|
| nico =人（） |
| nico.name =“尼科” |
| 打印“％ s名称为％s ”％（Person.name，nico.name） |
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
| 题： |
| 定义一个可以计算两个数字之和的函数。 |
|
|
| 提示： |
| 定义一个以两个数字作为参数的函数。您可以在函数中计算总和并返回值。 |
|
|
| 解 |
| def SumFunction（数字1，数字2）： |
| 返回数字1+数字2 |
|
|
| 打印SumFunction（1,2） |
|
|
| ＃----------------------------------------＃ |
| 题： |
| 定义一个可以将整数转换为字符串并在控制台中打印的函数。 |
|
|
| 提示： |
|
|
| 使用str（）将数字转换为字符串。 |
|
|
| 解 |
| def printValue（n）： |
| 打印str（n） |
|
|
| printValue（3） |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
| 定义一个可以将整数转换为字符串并在控制台中打印的函数。 |
|
|
| 提示： |
|
|
| 使用str（）将数字转换为字符串。 |
|
|
| 解 |
| def printValue（n）： |
| 打印str（n） |
|
|
| printValue（3） |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个函数，该函数可以接收两个字符串形式的整数并计算它们的总和，然后在控制台中将其打印出来。 |
|
|
| 提示： |
|
|
| 使用int（）将字符串转换为整数。 |
|
|
| 解 |
| def printValue（s1，s2）： |
| 打印int（s1）+ int（s2） |
|
|
| printValue（“ 3”，“ 4”）＃7 |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
|
|
| 题： |
| 定义一个函数，该函数可以接受两个字符串作为输入并将其连接起来，然后在控制台中将其打印出来。 |
|
|
| 提示： |
|
|
| 使用+连接字符串 |
|
|
| 解 |
| def printValue（s1，s2）： |
| 打印s1 + s2 |
|
|
| printValue（“ 3”，“ 4”）＃34 |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
|
|
| 题： |
| 定义一个可以接受两个字符串作为输入的函数，并在控制台中打印最大长度的字符串。如果两个字符串的长度相同，则该函数应逐行打印所有字符串。 |
|
|
| 提示： |
|
|
| 使用len（）函数获取字符串的长度 |
|
|
| 解 |
| def printValue（s1，s2）： |
| len1 = len（s1） |
| len2 = len（s2） |
| 如果len1> len2： |
| 打印s1 |
| elif len2> len1： |
| 打印s2 |
| 其他： |
| 打印s1 |
| 打印s2 |
|
|
|
|
| printValue（“一个”，“三个”） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个可以接受整数作为输入的函数，如果数字是偶数，则打印“它是偶数”，否则打印“它是奇数”。 |
|
|
| 提示： |
|
|
| 使用％运算符检查数字是偶数还是奇数。 |
|
|
| 解 |
| def checkValue（n）： |
| 如果n％2 == 0： |
| 打印“这是一个偶数” |
| 其他： |
| 打印“这是一个奇数” |
|
|
|
|
| checkValue（7） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个可以打印字典的函数，其中键是1到3之间的数字（都包括在内），值是键的平方。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式将条目放入字典中。 |
| 使用**运算符可获取数字的幂。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| d [1] = 1 |
| d [2] = 2 ** 2 |
| d [3] = 3 ** 2 |
| 打印d |
|
|
|
|
| printDict（） |
|
|
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个可以打印字典的函数，其中键是1到20之间的数字（都包括在内），值是键的平方。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式将条目放入字典中。 |
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| 对于范围在（1,21）中的i： |
| d [i] = i ** 2 |
| 打印d |
|
|
|
|
| printDict（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个可以生成字典的函数，其中键是1到20之间的数字（均包括在内），值是键的平方。该功能应仅打印值。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式将条目放入字典中。 |
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
| 使用keys（）迭代字典中的键。我们也可以使用item（）来获取键/值对。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| 对于范围在（1,21）中的i： |
| d [i] = i ** 2 |
| 对于d.items（）中的（k，v）： |
| 打印v |
|
|
|
|
| printDict（） |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个可以生成字典的函数，其中键是1到20之间的数字（均包括在内），值是键的平方。该功能应仅打印键。 |
|
|
| 提示： |
|
|
| 使用dict [key] = value模式将条目放入字典中。 |
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
| 使用keys（）迭代字典中的键。我们也可以使用item（）来获取键/值对。 |
|
|
| 解 |
| def printDict（）： |
| d = dict（） |
| 对于范围在（1,21）中的i： |
| d [i] = i ** 2 |
| 对于d.keys（）中的k： |
| 打印k |
|
|
|
|
| printDict（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个函数，该函数可以生成并打印一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。 |
|
|
| 提示： |
|
|
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
| 使用list.append（）将值添加到列表中。 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 对于范围在（1,21）中的i： |
| li.append（i ** 2） |
| 打印李 |
|
|
|
|
| printList（） |
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个函数，该函数可以生成一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。然后，该功能需要打印列表中的前5个元素。 |
|
|
| 提示： |
|
|
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
| 使用list.append（）将值添加到列表中。 |
| 使用[n1：n2]分割列表 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 对于范围在（1,21）中的i： |
| li.append（i ** 2） |
| 打印li [：5] |
|
|
|
|
| printList（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个函数，该函数可以生成一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。然后，该功能需要打印列表中的最后5个元素。 |
|
|
| 提示： |
|
|
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
| 使用list.append（）将值添加到列表中。 |
| 使用[n1：n2]分割列表 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 对于范围在（1,21）中的i： |
| li.append（i ** 2） |
| 打印李[-5：] |
|
|
|
|
| printList（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个函数，该函数可以生成一个列表，其中值是介于1到20之间的数字的平方（均包括在内）。然后，该函数需要打印列表中前5个元素以外的所有值。 |
|
|
| 提示： |
|
|
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
| 使用list.append（）将值添加到列表中。 |
| 使用[n1：n2]分割列表 |
|
|
| 解 |
| def printList（）： |
| li = list（） |
| 对于范围在（1,21）中的i： |
| li.append（i ** 2） |
| 打印李[5：] |
|
|
|
|
| printList（） |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 定义一个函数，该函数可以生成和打印一个元组，其中值是介于1和20之间的数字的平方（均包括在内）。 |
|
|
| 提示： |
|
|
| 使用**运算符可获取数字的幂。 |
| 使用range（）进行循环。 |
| 使用list.append（）将值添加到列表中。 |
| 使用tuple（）从列表中获取一个元组。 |
|
|
| 解 |
| def printTuple（）： |
| li = list（） |
| 对于范围在（1,21）中的i： |
| li.append（i ** 2） |
| 打印元组（li） |
|
|
| printTuple（） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 使用给定的元组（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 |
|
|
|
|
| ＃----------------------------------------＃ |
| 2.10 |
|
|
| 题： |
| 编写一个程序来生成并打印另一个在给定元组（1,2,3,4,5,6,7,8,9,10）中其值为偶数的元组。 |
|
|
| 提示： |
|
|
| 使用“ for”来迭代元组 |
| 使用tuple（）从列表中生成一个元组。 |
|
|
| 解 |
| tp =（1,2,3,4,5,6,7,8,9,10） |
| li = list（） |
| 对于我在TP中： |
| 如果tp [i]％2 == 0： |
| li.append（tp [i]） |
|
|
| tp2 =元组（li） |
| 打印tp2 |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 2.14 |
|
|
| 题： |
| 编写一个接受字符串作为输入的程序，如果该字符串是“ yes”或“ YES”或“ Yes”，则打印“ Yes”，否则打印“ No”。 |
|
|
| 提示： |
|
|
| 使用if语句判断条件。 |
|
|
| 解 |
| s = raw_input（） |
| 如果s ==“ yes”或s ==“ YES”或s ==“ Yes”： |
| 打印“是” |
| 其他： |
| 打印“否” |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 3.4 |
|
|
| 题： |
| 编写一个程序，该程序可以使用过滤器功能过滤列表中的偶数。列表为：[1,2,3,4,5,6,7,8,9,10]。 |
|
|
| 提示： |
|
|
| 使用filter（）过滤列表中的某些元素。 |
| 使用lambda定义匿名函数。 |
|
|
| 解 |
| li = [1,2,3,4,5,6,7,8,9,10] |
| evenNumbers = filter（lambda x：x％2 == 0，li） |
| 打印偶数 |
|
|
|
|
| ＃----------------------------------------＃ |
| 3.4 |
|
|
| 题： |
| 编写一个程序，该程序可以map（）创建一个列表，该列表的元素是[1,2,3,4,5,6,7,8,9,10]中的元素的平方。 |
|
|
| 提示： |
|
|
| 使用map（）生成一个列表。 |
| 使用lambda定义匿名函数。 |
|
|
| 解 |
| li = [1,2,3,4,5,6,7,8,9,10] |
| squaredNumbers = map（lambda x：x ** 2，li） |
| 打印平方数 |
|
|
| ＃----------------------------------------＃ |
| 3.5 |
|
|
| 题： |
| 编写一个程序，该程序可以map（）和filter（）组成一个列表，该列表的元素为[1,2,3,4,5,6,7,8,9,10]中的偶数平方。 |
|
|
| 提示： |
|
|
| 使用map（）生成一个列表。 |
| 使用filter（）过滤列表中的元素。 |
| 使用lambda定义匿名函数。 |
|
|
| 解 |
| li = [1,2,3,4,5,6,7,8,9,10] |
| evenNumbers = map（lambda x：x ** 2，filter（lambda x：x％2 == 0，li）） |
| 打印偶数 |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 3.5 |
|
|
| 题： |
| 编写一个程序，该程序可以使用filter（）创建一个列表，该列表的元素为1到20之间的偶数（均包括在内）。 |
|
|
| 提示： |
|
|
| 使用filter（）过滤列表中的元素。 |
| 使用lambda定义匿名函数。 |
|
|
| 解 |
| evenNumbers = filter（lambda x：x％2 == 0，range（1,21）） |
| 打印偶数 |
|
|
|
|
| ＃----------------------------------------＃ |
| 3.5 |
|
|
| 题： |
| 编写一个程序，该程序可以map（）创建一个列表，该列表的元素为1到20之间的数字平方（均包括在内）。 |
|
|
| 提示： |
|
|
| 使用map（）生成一个列表。 |
| 使用lambda定义匿名函数。 |
|
|
| 解 |
| squaredNumbers = map（lambda x：x ** 2，range（1,21）） |
| 打印平方数 |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 7.2 |
|
|
| 题： |
| 定义一个名为American的类，该类具有一个称为printNationality的静态方法。 |
|
|
| 提示： |
|
|
| 使用@staticmethod装饰器定义类的静态方法。 |
|
|
| 解 |
| American类（对象）： |
| @staticmethod |
| def printNationality（）： |
| 打印“美国” |
|
|
| anAmerican = American（） |
| anAmerican.printNationality（） |
| American.printNationality（） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 7.2 |
|
|
| 题： |
| 定义一个名为American的类及其子类NewYorker。 |
|
|
| 提示： |
|
|
| 使用类Subclass（ParentClass）定义一个子类。 |
|
|
| 解： |
|
|
| American类（对象）： |
| 通过 |
|
|
| NewYorker（美国）类： |
| 通过 |
|
|
| anAmerican = American（） |
| aNewYorker = NewYorker（） |
| 打印美国人 |
| 打印纽约 |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
|
|
| 7.2 |
|
|
| 题： |
| 定义一个名为Circle的类，该类可以由半径构造。Circle类具有一种可以计算面积的方法。 |
|
|
| 提示： |
|
|
| 使用def methodName（self）定义方法。 |
|
|
| 解： |
|
|
| Circle（对象）类： |
| def __init __（self，r）： |
| self.radius = r |
|
|
| def区域（个体）： |
| 返回self.radius ** 2 * 3.14 |
|
|
| aCircle =圆（2） |
| 打印aCircle.area（） |
|
|
|
|
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 7.2 |
|
|
| 定义一个名为Rectangle的类，该类可以通过长度和宽度来构造。Rectangle类具有可以计算面积的方法。 |
|
|
| 提示： |
|
|
| 使用def methodName（self）定义方法。 |
|
|
| 解： |
|
|
| Rectangle（object）类： |
| def __init __（self，l，w）： |
| self.length = l |
| self.width = w |
|
|
| def区域（个体）： |
| 返回self.length * self.width |
|
|
| aRectangle =矩形（2,10） |
| 打印aRectangle.area（） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 7.2 |
|
|
| 定义一个名为Shape的类及其子类Square。Square类具有一个init函数，该函数以长度作为参数。这两个类都有一个Area函数，该函数可以打印Shape的区域默认为0的形状的区域。 |
|
|
| 提示： |
|
|
| 要覆盖超类中的方法，我们可以在超类中定义一个具有相同名称的方法。 |
|
|
| 解： |
|
|
| 类Shape（object）： |
| def __init __（）： |
| 通过 |
|
|
| def区域（个体）： |
| 返回0 |
|
|
| 方形（形状）类： |
| def __init __（self，l）： |
| Shape .__ init __（个体） |
| self.length = l |
|
|
| def区域（个体）： |
| 返回self.length * self.length |
|
|
| aSquare =正方形（3） |
| 打印aSquare.area（） |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
|
|
| 请引发RuntimeError异常。 |
|
|
| 提示： |
|
|
| 使用raise（）引发异常。 |
|
|
| 解： |
|
|
| 引发RuntimeError（'出了点问题'） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 编写一个函数以计算5/0并使用try / except捕获异常。 |
|
|
| 提示： |
|
|
| 使用try / except捕获异常。 |
|
|
| 解： |
|
|
| def throws（）： |
| 返回5/0 |
|
|
| 尝试： |
| throws（） |
| 除了ZeroDivisionError： |
| 打印“除以零！” |
| 除了Exception以外，err： |
| 打印“捕获异常” |
| 最后： |
| 打印“最后阻止清理” |
|
|
|
|
| ＃----------------------------------------＃ |
| 定义一个自定义异常类，该类将字符串消息作为属性。 |
|
|
| 提示： |
|
|
| 要定义自定义异常，我们需要定义一个从Exception继承的类。 |
|
|
| 解： |
|
|
| 类MyError（Exception）： |
| “”“我自己的异常类 |
|
|
| 属性： |
| msg-错误说明 |
| “” |
|
|
| def __init __（self，msg）： |
| self.msg =味精 |
|
|
| 错误= MyError（“出问题了”） |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 假设我们有一些“ [email protected]”格式的电子邮件地址，请编写程序以打印给定电子邮件地址的用户名。用户名和公司名都仅由字母组成。 |
|
|
| 例： |
| 如果给该程序输入以下电子邮件地址： |
|
|
| [email protected] |
|
|
| 然后，程序的输出应为： |
|
|
| 约翰 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 提示： |
|
|
| 使用\ w匹配字母。 |
|
|
| 解： |
| 汇入 |
| emailAddress = raw_input（） |
| pat2 =“（\ w +）@（（\ w + \。）+（com））” |
| r2 = re.match（pat2，emailAddress） |
| 打印r2.group（1） |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 假设我们有一些“ [email protected]”格式的电子邮件地址，请编写程序以打印给定电子邮件地址的公司名称。用户名和公司名都仅由字母组成。 |
|
|
| 例： |
| 如果给该程序输入以下电子邮件地址： |
|
|
| [email protected] |
|
|
| 然后，程序的输出应为： |
|
|
| 谷歌 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 提示： |
|
|
| 使用\ w匹配字母。 |
|
|
| 解： |
| 汇入 |
| emailAddress = raw_input（） |
| pat2 =“（\ w +）@（\ w +）\。（com）” |
| r2 = re.match（pat2，emailAddress） |
| 打印r2.group（2） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 编写一个程序，该程序接受由空格分隔的单词序列作为输入，以仅打印由数字组成的单词。 |
|
|
| 例： |
| 如果给出以下单词作为程序输入： |
|
|
| 2只猫和3只狗。 |
|
|
| 然后，程序的输出应为： |
|
|
| ['2'，'3'] |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 提示： |
|
|
| 使用re.findall（）使用正则表达式查找所有子字符串。 |
|
|
| 解： |
| 汇入 |
| s = raw_input（） |
| 打印re.findall（“ \ d +”，s） |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
|
|
| 打印一个unicode字符串“ hello world”。 |
|
|
| 提示： |
|
|
| 使用u'strings'格式定义unicode字符串。 |
|
|
| 解： |
|
|
| unicodeString = u“你好，世界！” |
| 打印unicodeString |
|
|
| ＃----------------------------------------＃ |
| 编写程序以读取ASCII字符串并将其转换为utf-8编码的unicode字符串。 |
|
|
| 提示： |
|
|
| 使用unicode（）函数进行转换。 |
|
|
| 解： |
|
|
| s = raw_input（） |
| u = unicode（s，“ utf-8”） |
| 打印你 |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 编写特殊注释以指示Python源代码文件为unicode。 |
|
|
| 提示： |
|
|
| 解： |
|
|
| ＃-*-编码：utf-8-*- |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 编写一个程序，通过控制台（n> 0）输入给定的n输入来计算1/2 + 2/3 + 3/4 + ... + n / n + 1。 |
|
|
| 例： |
| 如果以下n作为程序输入： |
|
|
| 5 |
|
|
| 然后，程序的输出应为： |
|
|
| 3.55 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 提示： |
| 使用float（）将整数转换为float |
|
|
| 解： |
|
|
| n = int（原始输入（）） |
| 总和= 0.0 |
| 对于范围（1，n + 1）中的i： |
| 总和+ = float（float（i）/（i + 1）） |
| 列印总和 |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 编写程序进行计算： |
|
|
| 当n> 0时f（n）= f（n-1）+100 |
| 并且f（0）= 1 |
|
|
| 通过控制台输入给定的n（n> 0）。 |
|
|
| 例： |
| 如果以下n作为程序输入： |
|
|
| 5 |
|
|
| 然后，程序的输出应为： |
|
|
| 500 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 提示： |
| 我们可以在Python中定义递归函数。 |
|
|
| 解： |
|
|
| 定义f（n）： |
| 如果n == 0： |
| 返回0 |
| 其他： |
| 返回f（n-1）+100 |
|
|
| n = int（原始输入（）） |
| 打印f（n） |
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
|
|
| 斐波那契数列是根据以下公式计算的： |
|
|
|
|
| 如果n = 0，则f（n）= 0 |
| 如果n = 1，则f（n）= 1 |
| 如果n> 1，则f（n）= f（n-1）+ f（n-2） |
|
|
| 请编写一个程序，以控制台输入给定的n输入来计算f（n）的值。 |
|
|
| 例： |
| 如果以下n作为程序输入： |
|
|
| 7 |
|
|
| 然后，程序的输出应为： |
|
|
| 13 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 提示： |
| 我们可以在Python中定义递归函数。 |
|
|
|
|
| 解： |
|
|
| 定义f（n）： |
| 如果n == 0：返回0 |
| elif n == 1：返回1 |
| 否则：返回f（n-1）+ f（n-2） |
|
|
| n = int（原始输入（）） |
| 打印f（n） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 斐波那契数列是根据以下公式计算的： |
|
|
|
|
| 如果n = 0，则f（n）= 0 |
| 如果n = 1，则f（n）= 1 |
| 如果n> 1，则f（n）= f（n-1）+ f（n-2） |
|
|
| 请编写一个使用列表推导的程序，以控制台输入给定的n输入以逗号分隔的形式打印斐波那契数列。 |
|
|
| 例： |
| 如果以下n作为程序输入： |
|
|
| 7 |
|
|
| 然后，程序的输出应为： |
|
|
| 0,1,1,2,3,5,8,13 |
|
|
|
|
| 提示： |
| 我们可以在Python中定义递归函数。 |
| 使用列表推导从现有列表生成列表。 |
| 使用string.join（）连接字符串列表。 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
|
|
| 定义f（n）： |
| 如果n == 0：返回0 |
| elif n == 1：返回1 |
| 否则：返回f（n-1）+ f（n-2） |
|
|
| n = int（原始输入（）） |
| 值= [str（f（x））对于x在范围（0，n + 1）中 |
| 打印“，”。join（值） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 当控制台输入n时，请使用生成器编写一个程序，以逗号分隔的形式打印0到n之间的偶数。 |
|
|
| 例： |
| 如果以下n作为程序输入： |
|
|
| 10 |
|
|
| 然后，程序的输出应为： |
|
|
| 0,2,4,6,8,10 |
|
|
| 提示： |
| 使用yield生成发生器中的下一个值。 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
|
|
| def EvenGenerator（n）： |
| i = 0 |
| 当i <= n时： |
| 如果i％2 == 0： |
| 让我 |
| i + = 1 |
|
|
|
|
| n = int（原始输入（）） |
| 值= [] |
| 为我在EvenGenerator（n）中： |
| values.append（str（i）） |
|
|
| 打印“，”。join（值） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 当控制台输入n时，请使用生成器编写一个程序，以逗号分隔的形式打印可以在0和n之间被5和7整除的数字。 |
|
|
| 例： |
| 如果以下n作为程序输入： |
|
|
| 100 |
|
|
| 然后，程序的输出应为： |
|
|
| 0,35,70 |
|
|
| 提示： |
| 使用yield生成发生器中的下一个值。 |
|
|
| 如果将输入数据提供给问题，则应假定它是控制台输入。 |
|
|
| 解： |
|
|
| def NumGenerator（n）： |
| 对于范围（n + 1）中的i： |
| 如果i％5 == 0和i％7 == 0： |
| 让我 |
|
|
| n = int（原始输入（）） |
| 值= [] |
| 对于NumGenerator（n）中的i： |
| values.append（str（i）） |
|
|
| 打印“，”。join（值） |
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
|
|
| 请编写assert语句以验证列表[2,4,6,8]中的每个数字都是偶数。 |
|
|
|
|
|
|
| 提示： |
| 使用“断言表达式”进行断言。 |
|
|
|
|
| 解： |
|
|
| li = [2,4,6,8] |
| 对于我在李： |
| 断言i％2 == 0 |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个从控制台接受基本数学表达式的程序，并打印评估结果。 |
|
|
| 例： |
| 如果将以下字符串作为程序输入： |
|
|
| 35 + 3 |
|
|
| 然后，程序的输出应为： |
|
|
| 38 |
|
|
| 提示： |
| 使用eval（）评估表达式。 |
|
|
|
|
| 解： |
|
|
| 表达式= raw_input（） |
| 打印eval（表达式） |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个二进制搜索功能，该功能可以搜索已排序列表中的项目。该函数应返回列表中要搜索的元素的索引。 |
|
|
|
|
| 提示： |
| 使用if / elif处理条件。 |
|
|
|
|
| 解： |
|
|
| 导入数学 |
| def bin_search（li，element）： |
| 底部= 0 |
| 顶部= len（li）-1 |
| 指数= -1 |
| 而top> = bottom和index ==-1： |
| mid = int（math.floor（（top + bottom）/2.0）） |
| 如果li [mid] == element： |
| 指数=中 |
| elif li [mid]>元素： |
| 顶端= 1 |
| 其他： |
| 底部=中+1 |
|
|
| 回报指数 |
|
|
| li = [2,5,7,9,11,17,222] |
| 打印bin_search（li，11） |
| 打印bin_search（li，12） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个二进制搜索功能，该功能可以搜索已排序列表中的项目。该函数应返回列表中要搜索的元素的索引。 |
|
|
|
|
| 提示： |
| 使用if / elif处理条件。 |
|
|
|
|
| 解： |
|
|
| 导入数学 |
| def bin_search（li，element）： |
| 底部= 0 |
| 顶部= len（li）-1 |
| 指数= -1 |
| 而top> = bottom和index ==-1： |
| mid = int（math.floor（（top + bottom）/2.0）） |
| 如果li [mid] == element： |
| 指数=中 |
| elif li [mid]>元素： |
| 顶端= 1 |
| 其他： |
| 底部=中+1 |
|
|
| 回报指数 |
|
|
| li = [2,5,7,9,11,17,222] |
| 打印bin_search（li，11） |
| 打印bin_search（li，12） |
|
|
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请使用Python数学模块生成一个随机浮点，其值在10到100之间。 |
|
|
|
|
|
|
| 提示： |
| 使用random.random（）在[0,1]中生成随机浮点数。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.random（）* 100 |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请使用Python数学模块生成一个随机浮点，其值在5到95之间。 |
|
|
|
|
|
|
| 提示： |
| 使用random.random（）在[0,1]中生成随机浮点数。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.random（）* 100-5 |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序，使用随机模块和列表推导输出0到10之间的一个随机偶数。 |
|
|
|
|
|
|
| 提示： |
| 使用random.choice（）从列表中随机元素。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.choice（[如果i％2 == 0，则[i代表范围（11）中的i]] |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序以输出一个随机数，使用随机模块和列表推导，该随机数可被5和7整除（介于0和10之间，包括0和10）。 |
|
|
|
|
|
|
| 提示： |
| 使用random.choice（）从列表中随机元素。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.choice（[如果i％5 == 0和i％7 == 0，[i代表范围（201）中的i]） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 请编写一个程序以生成包含5个随机数（介于100和200之间）的列表。 |
|
|
|
|
|
|
| 提示： |
| 使用random.sample（）生成随机值列表。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.sample（range（100），5） |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序以随机生成一个列表，该列表包含5个偶数（介于100和200之间）。 |
|
|
|
|
|
|
| 提示： |
| 使用random.sample（）生成随机值列表。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.sample（[如果i％2 == 0，[i代表i在范围（100,201）中]，5） |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序以随机生成一个包含5个数字的列表，这些数字可被5和7整除（介于1和1000之间）。 |
|
|
|
|
|
|
| 提示： |
| 使用random.sample（）生成随机值列表。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.sample（[如果i％5 == 0和i％7 == 0，[i代表范围（1,1001）中的i]，5） |
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 请编写一个程序以随机打印7到15之间的一个整数。 |
|
|
|
|
|
|
| 提示： |
| 使用random.randrange（）到给定范围内的随机整数。 |
|
|
|
|
| 解： |
|
|
| 随机导入 |
| 打印random.randrange（7,16） |
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 请编写一个程序来压缩和解压缩字符串“ hello world！hello world！hello world！hello world！”。 |
|
|
|
|
|
|
| 提示： |
| 使用zlib.compress（）和zlib.decompress（）压缩和解压缩字符串。 |
|
|
|
|
| 解： |
|
|
| 导入zlib |
| s ='你好世界！你好世界！你好世界！你好世界！' |
| t = zlib.compress（s） |
| 打印t |
| 打印zlib.decompress（t） |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写程序以打印“ 1 + 1”的执行运行时间100次。 |
|
|
|
|
|
|
| 提示： |
| 使用timeit（）函数测量运行时间。 |
|
|
| 解： |
|
|
| 从timeit import Timer |
| t =计时器（“对于i在范围（100）：1 + 1”中） |
| 打印t.timeit（） |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序以随机播放并打印列表[3,6,7,8]。 |
|
|
|
|
|
|
| 提示： |
| 使用shuffle（）函数可以随机播放列表。 |
|
|
| 解： |
|
|
| 从随机导入洗牌 |
| li = [3,6,7,8] |
| 洗牌 |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序以随机播放并打印列表[3,6,7,8]。 |
|
|
|
|
|
|
| 提示： |
| 使用shuffle（）函数可以随机播放列表。 |
|
|
| 解： |
|
|
| 从随机导入洗牌 |
| li = [3,6,7,8] |
| 洗牌 |
| 打印李 |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序以生成所有句子，其中主语位于[“ I”，“ You”]中，动词位于[“ Play”，“ Love”]中，而宾语位于[“ Hockey”，“ Football”]中。 |
|
|
| 提示： |
| 使用list [index]表示法从列表中获取元素。 |
|
|
| 解： |
|
|
| subject = [“ I”，“ You”] |
| 动词= [“播放”，“爱”] |
| objects = [“ Hockey”，“ Football”] |
| 对于范围内的我（len（subjects））： |
| 对于范围内的j（len（动词））： |
| 对于范围内的k（len（objects））： |
| 句子=“％s％s％s”。％（主题[i]，动词[j]，宾语[k]） |
| 打印句子 |
|
|
|
|
| ＃----------------------------------------＃ |
| 请删除[5,6,77,45,22,12,24]中的删除偶数后编写程序以打印列表。 |
|
|
| 提示： |
| 使用列表推导从列表中删除一堆元素。 |
|
|
| 解： |
|
|
| li = [5,6,77,45,22,12,24] |
| li = [如果x％2！= 0，则x为li中的x。 |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 通过使用列表理解，请编写一个程序以删除在[12,24,35,70,88,120,155]中可被5和7整除的删除数字后打印列表。 |
|
|
| 提示： |
| 使用列表推导从列表中删除一堆元素。 |
|
|
| 解： |
|
|
| li = [12,24,35,70,88,120,155] |
| li = [如果x％5！= 0和x％7！= 0，则x在li中的x |
| 打印李 |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 通过使用列表理解，请编写一个程序以删除[12,24,35,70,88,120,155]中的第0、2、4、6个数字，然后打印列表。 |
|
|
| 提示： |
| 使用列表推导从列表中删除一堆元素。 |
| 使用enumerate（）获取（索引，值）元组。 |
|
|
| 解： |
|
|
| li = [12,24,35,70,88,120,155] |
| li = [如果i％2！= 0，则枚举（li）中（i，x）的x] |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 通过使用列表理解，请编写一个程序，生成一个3 * 5 * 8 3D数组，每个元素为0。 |
|
|
| 提示： |
| 使用列表推导来创建数组。 |
|
|
| 解： |
|
|
| array = [[[0 for col in range（8）] for col in range（5）] for row in range（3）] |
| 打印阵列 |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 通过使用列表理解，请编写一个程序以删除[12,24,35,70,88,120,155]中的第0、4、5个数字以打印列表。 |
|
|
| 提示： |
| 使用列表推导从列表中删除一堆元素。 |
| 使用enumerate（）获取（索引，值）元组。 |
|
|
| 解： |
|
|
| li = [12,24,35,70,88,120,155] |
| li = [如果我不在（0,4,5）中，则x（i，x）在enumerate（li）中] |
| 打印李 |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 通过使用列表理解，请在删除[12,24,35,24,88,120,155]中的值24之后编写程序以打印列表。 |
|
|
| 提示： |
| 使用列表的remove方法删除一个值。 |
|
|
| 解： |
|
|
| li = [12,24,35,24,88,120,155] |
| li = [如果x！= 24，则x表示li中的x。 |
| 打印李 |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 用两个给定的列表[1,3,6,78,35,55]和[12,24,35,24,88,120,155]，编写一个程序来制作一个列表，其元素是上述给定列表的交集。 |
|
|
| 提示： |
| 使用set（）和“＆=”进行交集操作。 |
|
|
| 解： |
|
|
| set1 = set（[1,3,6,78,35,55]） |
| set2 = set（[12,24,35,24,88,120,155]） |
| set1＆= set2 |
| li =列表（set1） |
| 打印李 |
|
|
| ＃----------------------------------------＃ |
|
|
| 使用给定的列表[12,24,35,24,88,120,155,88,120,155]，编写一个程序，在删除所有保留原始顺序的重复值之后，打印此列表。 |
|
|
| 提示： |
| 使用set（）存储许多值，不能重复。 |
|
|
| 解： |
|
|
| def removeDuplicate（li）： |
| newli = [] |
| 看到= set（） |
| 对于li中的项目： |
| 如果没有看到项目： |
| seen.add（item） |
| newli.append（项目） |
|
|
| 返回newli |
|
|
| li = [12,24,35,24,88,120,155,88,120,155] |
| 打印removeDuplicate（li） |
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 定义一个类Person及其两个子类：Male和Female。所有类都有一个方法“ getGender”，可以为“男”类打印“男”，为“女”打印“女”。 |
|
|
| 提示： |
| 使用Subclass（Parentclass）定义子类。 |
|
|
| 解： |
|
|
| 类Person（object）： |
| def getGender（self）： |
| 返回“未知” |
|
|
| 男（人）类： |
| def getGender（self）： |
| 返回“男” |
|
|
| 女类（人）： |
| def getGender（self）： |
| 返回“女” |
|
|
| aMale =男性（） |
| aFemale =女性 |
| 打印aMale.getGender（） |
| 打印aFemale.getGender（） |
|
|
|
|
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 请编写一个程序来计算和打印控制台输入的字符串中每个字符的编号。 |
|
|
| 例： |
| 如果将以下字符串作为程序输入： |
|
|
| abcdefgabc |
|
|
| 然后，程序的输出应为： |
|
|
| a2 |
| ，2 |
| ，2 |
| 1一 |
| d，1 |
| 1一 |
| ，1 |
|
|
| 提示： |
| 使用dict来存储键/值对。 |
| 使用dict.get（）方法查找具有默认值的键。 |
|
|
| 解： |
|
|
| dic = {} |
| s = raw_input（） |
| 对于s in s： |
| dic [s] = dic.get（s，0）+1 |
| 打印'\ n'.join（[。％s，％s'％（k，v）对于dic.items（）中的k，v） |
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 请编写一个程序，该程序从控制台接受一个字符串，然后以相反的顺序打印它。 |
|
|
| 例： |
| 如果将以下字符串作为程序输入： |
|
|
| 投票给先生 |
|
|
| 然后，程序的输出应为： |
|
|
| 里斯·埃托夫·埃西尔 |
|
|
| 提示： |
| 使用list [::-1]以相反的顺序迭代列表。 |
|
|
| 解： |
|
|
| s = raw_input（） |
| s = s [::-1] |
| 打印 |
|
|
| ＃----------------------------------------＃ |
|
|
| 题： |
|
|
| 请编写一个程序，该程序从控制台接受一个字符串，并打印具有偶数索引的字符。 |
|
|
| 例： |
| 如果将以下字符串作为程序输入： |
|
|
| H1e2l3l4o5w6o7r8l9d |
|
|
| 然后，程序的输出应为： |
|
|
| 你好，世界 |
|
|
| 提示： |
| 使用list [:: 2]通过步骤2迭代列表。 |
|
|
| 解： |
|
|
| s = raw_input（） |
| s = s [:: 2] |
| 打印 |
| ＃----------------------------------------＃ |
|
|
|
|
| 题： |
|
|
| 请编写一个打印所有[1,2,3]排列的程序 |
|
|
|
|
| 提示： |
| 使用itertools.permutations（）获取列表的排列。 |
|
|
| 解： |
|
|
| 导入itertools |
| 打印列表（itertools.permutations（[1,2,3]）） |
|
|
| ＃----------------------------------------＃ |
| 题： |
|
|
| 编写程序来解决经典的古代中国难题： |
| 我们在一个农场的鸡和兔子中算出35头和94腿。我们有多少只兔子和几只鸡？ |
|
|
| 暗示： |
| 使用for循环迭代所有可能的解决方案。 |
|
|
| 解： |
|
|
| defsolve（numheads，numlegs）： |
| ns ='没有解决方案！' |
| 对于我在范围内（numheads + 1）： |
| j =数字头 |
| 如果2 * i + 4 * j ==数字 |
| 返回我，j |
| 返回ns，ns |
|
|
| numheads = 35 |
| numlegs = 94 |
| 解决方案= solve（numheads，numlegs） |
| 打印解决方案 |
|
|
| ＃----------------------------------------＃ |
