原文地址：
问题一：以下的代码的输出将是什么? 说出你的答案并解释。
class&Parent(object):
class&Child1(Parent):
class&Child2(Parent):
print&Parent.x, Child1.x, Child2.x
Child1.x&=&2
print&Parent.x, Child1.x, Child2.x
Parent.x&=&3
print&Parent.x, Child1.x, Child2.x
1 1 11 2 13 2 3
使你困惑或是惊奇的是关于最后一行的输出是&3 2 3&而不是&3 2 1。为什么改变了&Parent.x&的值还会改变&Child2.x&的值，但是同时&Child1.x&值却没有改变？
这个答案的关键是，在 Python 中，类变量在内部是作为字典处理的。如果一个变量的名字没有在当前类的字典中发现，将搜索祖先类（比如父类）直到被引用的变量名被找到（如果这个被引用的变量名既没有在自己所在的类又没有在祖先类中找到，会引发一个&AttributeError&异常 ）。
因此，在父类中设置&x = 1&会使得类变量&X&在引用该类和其任何子类中的值为 1。这就是因为第一个 print 语句的输出是&1 1 1。
随后，如果任何它的子类重写了该值（例如，我们执行语句&Child1.x = 2），然后，该值仅仅在子类中被改变。这就是为什么第二个&print&语句的输出是&1 2 1。
最后，如果该值在父类中被改变（例如，我们执行语句&Parent.x = 3），这个改变会影响到任何未重写该值的子类当中的值（在这个示例中被影响的子类是&Child2）。这就是为什么第三个&print&输出是&3 2 3。
问题二：以下的代码的输出将是什么? 说出你的答案并解释？
def div1(x,y):
print("%s/%s = %s" % (x, y, x/y))
def div2(x,y):
print("%s//%s = %s" % (x, y, x//y))
div1(5.,2)
div2(5.,2.)
5/2 = 25.0/2.0=2.55/2=25/2=2
这个答案实际依赖于你使用的是 Python 2 还是 Python 3。
在 Python 3 中，期望的输出是：
5.0/2 = 2.5
在 Python 2 中，尽管如此，以上代码的输出将是：
5.0/2 = 2.5
默认，如果两个操作数都是整数，Python 2 自动执行整型计算。结果，5/2&值为&2，然而&5./2&值为 ```2.5``。
注意，尽管如此，你可以在 Python 2 中重载这一行为（比如达到你想在 Python 3 中的同样结果），通过添加以下导入：
from __future__ import division
也需要注意的是“双划线”（//）操作符将一直执行整除，而不管操作数的类型，这就是为什么&5.0//2.0&值为&2.0。
注： 在 Python 3 中，/&操作符是做浮点除法，而&//&是做整除（即商没有余数，比如 10 // 3 其结果就为 3，余数会被截除掉，而&(-7) // 3&的结果却是&-3。这个算法与其它很多编程语言不一样，需要注意，它们的整除运算会向0的方向取值。而在 Python 2 中，/&就是整除，即和 Python 3 中的&//&操作符一样，）
问题三：以下代码将输出什么?
list = ['a', 'b', 'c', 'd', 'e']
print list[10:]
以上代码将输出&[]，并且不会导致一个&IndexError。
正如人们所期望的，试图访问一个超过列表索引值的成员将导致&IndexError（比如访问以上列表的&list[10]）。尽管如此，试图访问一个列表的以超出列表成员数作为开始索引的切片将不会导致&IndexError，并且将仅仅返回一个空列表。
一个讨厌的小问题是它会导致出现 bug ，并且这个问题是难以追踪的，因为它在运行时不会引发错误。
问题四：以下的代码的输出将是什么? 说出你的答案并解释？
def multipliers():
return [lambda x : i * x for i in range(4)]
print [m(2) for m in multipliers()]
你将如何修改&multipliers&的定义来产生期望的结果
以上代码的输出是&[6, 6, 6, 6]&（而不是&[0, 2, 4, 6]）。
这个的原因是 Python 的闭包的后期绑定导致的&，这意味着在闭包中的变量是在内部函数被调用的时候被查找。所以结果是，当任何&multipliers()&返回的函数被调用，在那时，i&的值是在它被调用时的周围作用域中查找，到那时，无论哪个返回的函数被调用，for&循环都已经完成了，i&最后的值是&3，因此，每个返回的函数&multiplies&的值都是 3。因此一个等于 2 的值被传递进以上代码，它们将返回一个值 6 （比如： 3 x 2）。
（顺便说下，正如在&&中指出的，这里有一点普遍的误解，是关于&lambda&表达式的一些东西。一个&lambda&表达式创建的函数不是特殊的，和使用一个普通的&def&创建的函数展示的表现是一样的。）
这里有两种方法解决这个问题。
最普遍的解决方案是创建一个闭包，通过使用默认参数立即绑定它的参数。例如：
def multipliers():
return [lambda x, i=i : i * x for i in range(4)]
另外一个选择是，你可以使用&functools.partial&函数：
from functools import partial
from operator import mul
def multipliers():
return [partial(mul, i) for i in range(4)]
问题五：以下的代码的输出将是什么? 说出你的答案并解释？
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3
你将如何修改&extendList&的定义来产生期望的结果
以上代码的输出为：
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']
许多人会错误的认为&list1&应该等于&[10]&以及&list3&应该等于&['a']。认为&list&的参数会在&extendList&每次被调用的时候会被设置成它的默认值&[]。
尽管如此，实际发生的事情是，新的默认列表仅仅只在函数被定义时创建一次。随后当&extendList&没有被指定的列表参数调用的时候，其使用的是同一个列表。这就是为什么当函数被定义的时候，表达式是用默认参数被计算，而不是它被调用的时候。
因此，list1&和&list3&是操作的相同的列表。而 ````list2是操作的它创建的独立的列表（通过传递它自己的空列表作为list``` 参数的值）。
extendList&函数的定义可以做如下修改，但，当没有新的&list&参数被指定的时候，会总是开始一个新列表，这更加可能是一直期望的行为。
def extendList(val, list=None):
if list is None:
list.append(val)
return list
使用这个改进的实现，输出将是：
list1 = [10]
list2 = [123]
list3 = ['a']
阅读(...) 评论()list = ['a', 'b', 'c', 'd', 'e']
print list[10:]
上面的代码输出[]，并且不会导致IndexError错误
跟你想的一样，当取列表元素的时候，如果索引值超过了元素的个数(例如在上面的列表中，取list[10])将会导致IndexError错误。但是，取一个列表的切片的时候，如果起始索引超过了元素个数，将不会引起IndexError错误，仅返回一个空列表。
这一特性将会导致一些非常难于追踪的bug，因为在运行时根本没有错误产生。
def div1(x,y):
print "%s/%s = %s" % (x, y, x/y)
def div2(x,y):
print "%s//%s = %s" % (x, y, x//y)
div1(5.,2)
div2(5.,2.)
另外，在Python3中上面的代码的输出有何不同(假设代码中的print语句都转化成了Python3中的语法结构)？
在Python2中，代码的输出是：
5.0/2 = 2.5
默认情况下，如果两个操作数都是整数，Python2默认执行整数运算。所以，5/2 结果是2，而5./2结果是2.5
注意你可以通过下面的import语句来覆盖Python2中的这一行为
from __future__ import division
还要注意“双斜杠”(//)操作符将会一直执行整除，忽略操作数的类型。这就是为什么5.0//2.0即使在Python2中结果也是2.0
但是在Python3两个操作数都是整数时，也不执行整数运算。在Python3中，输出如下：
单斜杠在python2默认整除但是可以类型提升，pyhton3一律按照浮点操作。
5.0/2 = 2.5
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3
如何修改函数ExtendList的定义才能产生我们希望的行为？
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']
很多人会错误地预计list1等于［10］，list3等于['a']，认为extendList函数的list参数在每一次函数被调用时都会被设置为默认值[]
但是，真实的情况是，默认的list只在函数定义的时候被创建一次。之后不指定list参数地调用extendList函数时，使用的都是同一个list。这是因为默认参数在函数定义的时候被计算的，而不是在函数调用时。
question:既然的默认参数都是在定义时计算的，下次调用时会调用统一个list,那最后一个怎么不得24呢？？？
所以，list1和list3都是在操作同一个默认list，而list2是在操作它自己创建的一个独立的list(将自己的空list作为参数传递过去)
extendlist的定义可以这样定义来达到我们预期的效果：
def extendList(val, list=None):
if list is None:
list.append(val)
return list
调用修改后的函数，输出是：
list1 = [10]
list2 = [123]
list3 = ['a']
class Parent(object):
class Child1(Parent):
class Child2(Parent):
print Parent.x, Child1.x, Child2.x
Child1.x = 2
print Parent.x, Child1.x, Child2.x
Parent.x = 3
print Parent.x, Child1.x, Child2.x
让很多人感到疑惑和惊讶的是，最后一行的输出竟然不是3 2 1而是3
2 3. 为什么修改了Parent.X的值会影响到Child2.x，但是同时又没有改变Child1.x的值呢？
这个问题的关键在于，在python中，类中的变量在内部被当作字典处理。如果一个变量名在当前类的字典中没有被发现，系统将会在这个类的祖先(例如，它的父类)中继续寻找，直到找到为止(如果一个变量名在这个类和这个类的祖先中都没有，那么将会引发一个AttributeError错误)
因此，在父类中将变量x赋值为1，那么x变量将可以被当前类和所有这个类的子类引用。这就是为什么第一个print语句输出为1 1 1.
接下来，如果它的子类覆盖了这个值(例如， 当我们执行Child1.x = 2)，那么这个变量的值仅仅在这个子类中发生了改变。这就是为什么第二个print语句输出1
最后，如果父类改变了这个变量的值(例如，我们执行Parent.x = 3)，所有没有覆盖这个参数值的子类(在这个例子中覆盖了参数的就是Child2)都会受到影响，这就是为什么第三个print语句的输出为3
def multipliers():
return [lambda x : i * x for i in range(4)]
print [m(2) for m in multipliers()]
怎么修改multipliers的定义才能达到期望的效果？
上面代码的输出是[6, 6, 6, 6](不是[0,
2, 4, 6]).
原因是Python的闭包是延迟绑定(late binding)的。这表明在闭包中使用的变量直到内层函数被调用的时候才会被查找。结果是，当调用multipliers()返回的函数时，i参数的值会在这时被在调用环境中查找。所以，无论调用返回的哪个函数，for循环此时已经结束，i等于它最终的值3。因此，所有返回的函数都要乘以传递过来的3，因为上面的代码传递了2作为参数，所以他们都返回了6（即，3
(顺便提一句，正如在书中提出来的一样, 有一种广泛传播的误解认为这个问题和lambda表达式有关，事实并非如此。通过labda表达式产生的函数并没有什么特别之处，使用普通的def定义的函数的行为和lambda表达式产生的函数的行为是一样的.)
下面是一些可以绕过这个问题的方法。
方法一是像下面一样使用Python的生成器(generator)
def multipliers():
for i in range(4): yield lambda x : i * x
另一个方法是创造一个闭包，通过使用一个默认参数来立即绑定它的参数
def multipliers():
return [lambda x, i=i : i * x for i in range(4)]
或者，你也可以使用functools.partial函数：
from functools import partial
from operator import mul
def multipliers():
return [partial(mul, i) for i in range(4)]
1. list = [ [ ] ] * 5
3. list[0].append(10)
5. list[1].append(20)
7. list.append(30)
第2，4，6，8行的输出是什么？解释你的答案.
[[], [], [], [], []]
[[10], [10], [10], [10], [10]]
[[10, 20], [10, 20], [10, 20], [10, 20], [10, 20]]
[[10, 20], [10, 20], [10, 20], [10, 20], [10, 20], 30]
下面是解释:
第一行的输出凭直觉就能知道，很容易理解。即：list = [ [ ] ] * 5创建了一个元素是5个列表的列表。
但是，这里要理解的关键是，list = [ [ ] ] * 5并没有创建一个包含5个不同列表的列表。创建的这个列表里的5个列表，是对同一个列表的引用（a
a list of 5 references to the same list）。理解了这些，你就能更好地理解余下的输出。
list[0].append(10)将数字10添加到第一个列表。但是由于5个列表是对同一个列表的引用，所以输出是[[10],
[10], [10], [10], [10]]。
同样的，list[1].append(20)将20追加到第二个列表。但是同样，由于这5个列表引用同一个列表，所以输出：[[10,
20], [10, 20], [10, 20], [10, 20], [10, 20]].
相比之下， list.append(30)是将一个全新的元素追加到“外层”的列表，所以产生了这样的输出：[[10,
20], [10, 20], [10, 20], [10, 20], [10, 20], 30].
偶数，以及
在原列表中，索引为偶数
例如，如果list[2]的值是偶数，那么这个元素应该也被包含在新列表中，因为它在原列表中的索引也是偶数(即 2). 但是， 如果list[3]是偶数，那这个值不应该被包含在新列表中，因为它在原列表中的索引是一个奇数。
一个简单的解法如下：
[x for x in list[::2] if x%2 == 0]
例如，给出下面的列表:
list = [ 1 , 3 , 5 , 8 , 10 , 13 , 18 , 36 , 78 ]
列表解析式[x for x in list[::2] if x%2 == 0] 会生成:
[10, 18, 78]
这个表达式首先取列表中索引是偶数的数字，然后过滤掉所有的奇数.
Python练手经典100例
本博文转载自：http://blog.csdn.net/dajiangtai007/article/details/
Python面试题汇总
拿网络上关于Python的面试题汇总了，给出了自认为合理的答案，有些题目不错，可以从中学到点什么.........
1000道Python题库系列分享四（40道）
热烈庆祝2018年2月董付国老师《Python程序设计（第2版）》出版18个月第5次印刷，《Python可以这样学》出版12个月第5次印刷，系列教材《Python程序设计基础》、《Python程序设计...
&em&Python&/em&入门&em&经典&/em& The Practice of Computing Using &em&Python&/em& 2nd Edition by William F Punch and Ric 书&em&+代码&/em& 综合评分:5 收藏(3)评论(26)举报 所需: 11积分/C...
列表排序def que6():
# 6.输入三个整数x, y, z，形成一个列表，请把这n个数由小到大输出。
# 程序分析：列表有sort方法，所以把他们组成列表即可。
《&em&Python&/em&编程入门&em&经典&/em&》(作者James Payne)主要介绍&em&Python&/em& 3.1。&em&Python&/em& 3.1发布于2009年,是&em&Python&/em&程序语言的最新主版本。由于&em&Python&/em&是一门跨平台的语言,本书中的内容...
Python 简介Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其...
Python零基础入门之三---（for循环+列表）
Python的for循环与C、C++等语言的for循环的结构还是有很大的差别的，不过还是很容易上手的，Python的列表类似于C语言中的数组，但是相比数组的功能更加强大，玩笑话是说打了激素中的数组。
没有更多推荐了，六个常见的Python面试题【附答案】
Python学习交流:&&&&备注：小白
是否遇到过的模块间循环引用的问题，如何避免它?
这是代码结构设计的问题，模块依赖和类依赖
如果老是觉得碰到循环引用可能的原因有几点：
1.可能是模块的分界线划错地方了
2.可能是把应该在一起的东西硬拆开了
3.可能是某些职责放错地方了
4.可能是应该抽象的东西没抽象
总之微观代码规范可能并不能帮到太多，重要的是更宏观的划分模块的经验技巧，推荐uml，脑图，白板等等图形化的工具先梳理清楚整个系统的总体结构和职责分工
采取办法，从设计模式上来规避这个问题，比如:
1. 使用 “__all__” 白名单开放接口
2. 尽量避免 import
Python中如何定义一个函数
有2种方法：
def func(arg, *args, **kwagrs): #普通函数
lambda x: x **2 #匿名函数
请写出一段Python代码实现删除一个list里面的重复元素
&&& L1 = [4,1,3,2,3,5,1]
&&& L2 = []
&&& [L2.append(i) for i in L1 if i not
&&& print L2
[4, 1, 3, 2, 5]
运行结果如下图：
Python是如何进行内存管理的？
python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。所有这些都是自动完成，不需要像C一样，人工干预，从而提高了程序员的效率和程序的健壮性。
写一个简单的Python socket编程。
socket是用来进行网络编程用的接口，网络编程分为服务器端和客户端
服务器端代码如下：
import socket
sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
sock.bind(('localhost', 8001))
sock.listen(5)
while True:
conn, addr = sock.accept()
conn.settimeout(5)
buff = conn.recv(1024)
if buff == '1':
conn.send('Hello, Client...')
conn.send('Please, Go Out...')
except socket.timeout:
print 'Socket Time Out...'
conn.close()
客户端代码如下：
import socket
import time
sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
sock.connect(('localhost', 8001))
time.sleep(2)
sock.send('1')
print sock.recv(1024)
sock.close()
"security/afafsff/?ip=123.4.56.78&id=45"，请写一段代码用正则匹配出IP。
"security/afafsff/?ip=123.4.56.78&id=45"
re.search('ip=(d{1,3}.d{1,3}.d{1,3}.d{1,3})', src, re.S) # re.S
改变'.'的行为
print m.group(1)
# 输出结果
123.4.56.78
运行结果如下：
推荐阅读：
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。&>&Python从菜鸟到大神的100道经典练习题
Python从菜鸟到大神的100道经典练习题
上传大小：901KB
从菜鸟到大神的100道经典练习题
综合评分：4
{%username%}回复{%com_username%}{%time%}\
/*点击出现回复框*/
$(".respond_btn").on("click", function (e) {
$(this).parents(".rightLi").children(".respond_box").show();
e.stopPropagation();
$(".cancel_res").on("click", function (e) {
$(this).parents(".res_b").siblings(".res_area").val("");
$(this).parents(".respond_box").hide();
e.stopPropagation();
/*删除评论*/
$(".del_comment_c").on("click", function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_invalid/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parents(".conLi").remove();
alert(data.msg);
$(".res_btn").click(function (e) {
var parentWrap = $(this).parents(".respond_box"),
q = parentWrap.find(".form1").serializeArray(),
resStr = $.trim(parentWrap.find(".res_area_r").val());
console.log(q);
//var res_area_r = $.trim($(".res_area_r").val());
if (resStr == '') {
$(".res_text").css({color: "red"});
$.post("/index.php/comment/do_comment_reply/", q,
function (data) {
if (data.succ == 1) {
var $target,
evt = e || window.
$target = $(evt.target || evt.srcElement);
var $dd = $target.parents('dd');
var $wrapReply = $dd.find('.respond_box');
console.log($wrapReply);
//var mess = $(".res_area_r").val();
var mess = resS
var str = str.replace(/{%header%}/g, data.header)
.replace(/{%href%}/g, 'http://' + window.location.host + '/user/' + data.username)
.replace(/{%username%}/g, data.username)
.replace(/{%com_username%}/g, data.com_username)
.replace(/{%time%}/g, data.time)
.replace(/{%id%}/g, data.id)
.replace(/{%mess%}/g, mess);
$dd.after(str);
$(".respond_box").hide();
$(".res_area_r").val("");
$(".res_area").val("");
$wrapReply.hide();
alert(data.msg);
}, "json");
/*删除回复*/
$(".rightLi").on("click", '.del_comment_r', function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_comment_del/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parent().parent().parent().parent().parent().remove();
$(e.target).parents('.res_list').remove()
alert(data.msg);
//填充回复
function KeyP(v) {
var parentWrap = $(v).parents(".respond_box");
parentWrap.find(".res_area_r").val($.trim(parentWrap.find(".res_area").val()));
评论共有3条
要的积分太多了，不值这么多。
有题目可以多练习
不错呀，有题目，有解答，可以多练练。
VIP会员动态
热门资源标签
CSDN下载频道资源及相关规则调整公告V11.10
下载频道用户反馈专区
下载频道积分规则调整V1710.18
spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip
资源所需积分/C币
当前拥有积分
当前拥有C币
输入下载码
为了良好体验，不建议使用迅雷下载
Python从菜鸟到大神的100道经典练习题
会员到期时间：
剩余下载个数：
剩余积分：0
为了良好体验，不建议使用迅雷下载
积分不足！
资源所需积分/C币
当前拥有积分
您可以选择
程序员的必选
绿色安全资源
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
您的积分不足，将扣除 10 C币
为了良好体验，不建议使用迅雷下载
无法举报自己的资源
你当前的下载分为234。
你还不是VIP会员
开通VIP会员权限，免积分下载
你下载资源过于频繁，请输入验证码
您因违反CSDN下载频道规则而被锁定帐户，如有疑问，请联络:!
若举报审核通过，可返还被扣除的积分
被举报人：
machen_smiling
请选择类型
资源无法下载 （ 404页面、下载失败、资源本身问题）
资源无法使用 （文件损坏、内容缺失、题文不符）
侵犯版权资源 （侵犯公司或个人版权）
虚假资源 （恶意欺诈、刷分资源）
含色情、危害国家安全内容
含广告、木马病毒资源
*投诉人姓名：
*投诉人联系方式：
*版权证明：
*详细原因：
Python从菜鸟到大神的100道经典练习题Python来做应用题及思路
最近找工作头疼没事就开始琢磨python解应用题应该可以,顺便还可以整理下思路当然下面的解法只是个人理解，也欢迎大佬们给意见或者指点更好的解决办法等于优化代码了嘛，也欢迎大家出点小题目做也可以,如果可以我也会定期专门来做应用题（你弟弟或者你表弟或者外甥等来问应用题在也不用算了，把思路和答案给他让他自己一边研究去。）好了先来看如下题目:
1.firstblood题目一：
55名学生围成一个圆圈站好，并按照顺时针的方向依次编号1~55。然后1开始报数，隔一个人3号继续报数，接着是5号，7号……每一轮中，没有报数的同学都走出队伍，知道剩下最后一个人。请问最后一个站在队伍中的人是几号？
首先来聊聊题目中的信息提取也就是程序已知的参数，55个学生可以当一个列表，报数是1，3，5，7隔着报数，偶数位的都被排除，一轮排除后剩下的等于是接到前面列表结束位置的数55继续排除，这里要提醒前面的55这时候就是剩下的第一位，那么数字1就是第二位，等于我们要把每次循环的第一位给排除掉，才能无缝衔接，只要能理解这个很重要的一点这程序就通了。话不多说上代码了：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
students = [x for x in range(1,56)] #生成学生1到55个学生列表
print students
#打印出来后面对比
def leave(team):
#定义函数，因为题目剩下的学生还要继续所以用递归的方式
spare = []
#临时创库用于存放每次报数后剩下的学生
if len(team)&1:
#判断这个队列的长度不能小于1避免无限递归
for i in range(len(team)+1): #记住这里要的是列表的下标偶数而不是数字偶数（留给你们自己思考）
#重点中的重点无缝连接55后面下次循环1等于2的位置所以直接排除
if i%2==0:
#队列中偶数下标的人也就是1，3，5中间的2，4排除掉
#前面排除后剩下的学生存放到临时仓库
spare.append(team[i-1])
print spare
#打印后面衔接的剩下学生
if len(spare)&2:
#判断到最后只要两位就是接可以得出结果（由于上面第一位就直接排除的原因）
leave(spare)
#迭代函数再次排除偶数位置的学生
print spare[1]
#最后剩下两个人时其实第一个人就直接排除剩下就是最后一个报数的人
print "Who lies!!!"
#如果没人就打印谁乱报数
leave(students)
程序思路是：首先要循环接力报数，然户要递减人数我这里就用递归的方法，需要递减偶数位置，我这里用列表下标方式对应位置（偶数出列），然后限定条件，就是找到剩余几个人结束，由于每次第一个人直接排除所以到剩下两个人时排除第一个位置后就是答案。下面是结果：
2.double kill题目二
有一个监狱犯人吃饭时,如果3个人坐一桌则余2人,5个人坐一桌则余4,7个人坐一桌则余6人,9个人坐一桌则余8人,11个人坐一桌正好坐满,问一共有多少犯人?
还是来先提取题目中的参数信息，如果关键字可以看成程序中的条件if对待，总数X%3=2，X%5=4.......X%9=8..X%11=0,其实这写都是条件，注意的是犯人的总数是要同时满足这几个条件，而不是满足其中一个。是不是思路很清晰了我们可以用程序的and方法就是条件全满足时执行。来看看代码:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
1，首先我们不知道这个数，所以可以用X未知数来表示
2，估计一个范围，因为这个数字不是唯一的，答案也不是唯一的除非是选择题目
3，我会用两种写法来解答，各位自己取舍理解好用就行。
for x in range(10000):
if x%3==2 and x%5==4 and x%7==6 and x%9==8 and x%11==<span style="color: #:
print [x for x in range(10000) if x%3==2 and x%5==4 and x%7==6 and x%9==8 and x%11==0]
是不是很简单只用把条件放去循环内部，程序会自己判断取值，这里我定义的范围是1万内满足条件的输出，上面常用的for循环写法，下面就是列表解析式，大家觉得那种好理解就用哪种吧！！！来看结果如下(有3个数满足条件):
3.triple kill题目三:
两火车相距10千米，A火车每小时1千米速度前行，B火车每小时2千米速度前行，求B几小时后追上A？
首先参数是A的长度是10千米，B为0千米，然后计算小时用一个计数器初始为0，然后要用到循环A每次加1千米，B每次加2千米，计数器来计算循环次数也就是几小时后追上A火车。代码如下：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
for i in range(10):
#初始化一个A已经跑了个距离
A.append("<span style="color: #")
#用1表示每小时走了1千米
#打印一个原始数据
print "--------------分割线-------------------"
#初始化B列车
#小时计数器统计用了几小时
for h in range(100):
if len(A)!=len(B):
#当A走的范围不等于B走的范围时
A.append("<span style="color: #")
#A每次走1千米
B.append("<span style="color: #")
#B每次走2千米走了两次
B.append("<span style="color: #")
#每次执行就代表用了一小时所以要加上
elif len(A)==len(B):
#当A走的距离等于B走的距离时
print "追上了A"
#提醒已经追上A
#每次打印走的距离
print "B追上A花了%d小时"%count
基本都在注释上面，很容易理解，是不是觉得很有趣，用python来做应用题锻炼思路很好的方法，可以锻炼对问题的分析及处理过程。
好了最后还是感谢观看，下次再见！！！
阅读(...) 评论()}