100多个具有挑战性的Python编程练习，你能答对几题

	超过100个具有挑战性的Python编程练习
	1.等级说明
	等级说明
	1级初学者是指刚刚参加Python入门课程的人。他可以使用1或2个Python类或函数解决一些问题。通常，答案可以直接在教科书中找到。
	2级中级是指刚刚学习过Python，但是已经具有相对较强的编程背景的人。他应该能够解决可能涉及3或3个Python类或函数的问题。答案不能直接在教科书中找到。
	3级高级。他应该使用Python通过更丰富的库函数，数据结构和算法来解决更复杂的问题。他应该使用几种Python标准软件包和高级技术来解决该问题。
	交流扣裙：606115027

2.问题模板
	＃----------------------------------------＃
	题
	提示
	解

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级
	题：
	编写一个程序，该程序从控制台接受一个逗号分隔的数字序列，并生成一个列表和一个包含每个数字的元组。
	假设将以下输入提供给程序：交流扣裙：606115027
	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
	而我
	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：
	让我