Python几种并发实现方案性能比较.docx

偶然看到Erlang vs. Stackless python: a first benchmark，对Erlang和Stackless Python的并发处理性能进行了实验比较，基本结论认为二者有比较相近的性能。我看完产生的问题是，Stackless Python与Python的其他并发实现机制性能又会有多大区别呢，比如线程和进程。因此我采用与这篇文章相同的办法来对Stackless Python、普通Python的thread模块、普通Python的threading模块、普通Python的processing模块这四种并发实现方案进行了性能实验，并将实验

实验方案与Erlang vs. Stackless python: a first benchmark是相同的，用每种方案分别给出如下问题的实现，记录完成整个处理过程的总时间来作为评判性能的依据：

1.由n个节点组成一个环状网络，在上面传送共m个消息。

2.将每个消息（共m个），逐个发送给1号节点。

3.第1到n-1号节点在接收到消息后，都转发给下一号节点。

4.第n号节点每次收到消息后，不再继续转发。

5.当m个消息都从1号逐个到达第n号节点时，认为全部处理结束。

(Edit Section ↓)

2.1 硬件平台

Macbook Pro 3,1上的Vmware Fusion 1.0虚拟机中，注意这里给虚拟机只启用了cpu的单个核心：

?原始Cpu：Core 2 Duo，2.4 GHz，2核心，4 MB L2 缓存，总线速度800 MHz

?分配给虚拟机的内存：796M

（单个CPU，还能比较并发吗？）

(Edit Section ↓)

2.2 软件平台

Vmware Fusion 1.0下的Debian etch：

?原始Python：Debian发行版自带Python 2.4.4

?Python 2.4.4 Stackless 3.1b3 060516

?processing-0.52-py2.4-linux-i686.egg

?原始Python下的greenlet实现：py lib 0.9.2

各方案的实现代码见后文。实验时使用time指令记录每次运行的总时间，选用的都是不做任何输出的no_io实现（Python的print指令还是挺耗资源的，如果不注释掉十有八九得影响测试结果），每次执行时设定n=300，m=10000（Erlang vs. Stackless python: a first benchmark文章中认为n可以设置为300，m则可以取10000到90000之间的数值分别进行测试）。

(Edit Section ↓)

3.1 Stackless Python的实验结果

real 0m1.651s

user 0m1.628s

sys 0m0.020s

即使将m扩大到30000，实验结果仍然很突出：

real 0m4.749s

user 0m4.716s

sys 0m0.028s

(Edit Section ↓)

3.2 使用thread模块的实验结果

real 1m13.009s

user 0m2.476s

sys 0m59.028s

(Edit Section ↓)

3.3 使用threading模块配合Queue模块的实验结果不太稳定，有时候这样：

real 1m9.222s

user 0m34.418s

sys 0m34.622s

也有时这样：

real 2m14.016s

user 0m6.644s

sys 2m7.260s

(Edit Section ↓)

3.4 使用processing模块配合Queue模块的实验结果real 3m43.539s

user 0m15.345s

sys 3m27.953s

(Edit Section ↓)

4.1 Stackless Python

毫无疑问，Stackless Python几乎有匪夷所思的并发性能，比其他方案快上几十倍，而且借助Stackless Python提供的channel机制，实现也相当简单。也许这个结果向我们部分揭示了沈仙人基于Stackless Python实现的Eurasia3能够提供相当于c语言效果的恐怖并发性能的原因。

(Edit Section ↓)

4.2 Python线程

从道理上来讲，thread模块似乎应该和threading提供基本相同的性能，毕竟threading只是对thread的一种封装嘛，后台机制应该是一致的。或许threading 由于本身类实例维护方面的开销，应该会比直接用thread慢一点。从实验结果来看，二者性能也确实差不多。只是不大明白为何threading方案的测试结果不是很稳定，即使对其他方案的测试运行多次，误差也不会像threading这么飘。从代码实现体验来说，用threading配合Queue比直接用thread实在是轻松太多了，并且出错的机会也要少很多。

(Edit Section ↓)

4.3 Python进程

processing模块给出的进程方案大致比thread线程要慢一倍，并且这是在我特意调整虚拟机给它预备了足够空闲内存、避免使用交换分区的情况下取得的（特意分给虚拟机700多M内存就是为了这个）。而其他方案仅仅占用数M内存，完全无需特意调大可用内存总量。当然，如果给虚拟机多启用几个核心的话，processing也许会占上点便宜，毕竟目前thread模块是不能有效利用多cpu资源的（经实验，Stackless Python在开启双核的情况下表现的性能和单核是一样的，说明也是不能有效利用多cpu）。因此一种比较合理的做法是根据cpu的数量，启用少量几个进程，而在进程内部再开启线程进行实际业务处理，这也是目前Python社区推荐的有效利用多cpu资源的办法。好在processing配合其自身提供的Queue模块，编程体验还是比较轻松的。

(Edit Section ↓)

4.4 greenlet超轻量级方案

基于greenlet的实现则性能仅次于Stackless Python，大致比Stackless Python 慢一倍，比其他方案快接近一个数量级。其实greenlet不是一种真正的并发机制，而是在同一线程内，在不同函数的执行代码块之间切换，实施“你运行一会、我运行一会”，并且在进行切换时必须指定何时切换以及切换到哪。greenlet的接口是比较简单易用的，但是使用greenlet时的思考方式与其他并发方案存在一定区别。线程/进程模型在大逻辑上通常从并发角度开始考虑，把能够并行处理的并且值得并行处理的任务分离出来，在不同的线程/进程下运行，然后考虑分离过程可能造成哪些互斥、冲突问题，将互斥的资源加锁保护来保证并发处理

的正确性。greenlet则是要求从避免阻塞的角度来进行开发，当出现阻塞时，就显式切换到另一段没有被阻塞的代码段执行，直到原先的阻塞状况消失以后，再人工切换回原来的代码段继续处理。因此，greenlet本质是一种合理安排了的串行，实验中greenlet方案能够得到比较好的性能表现，主要也是因为通过合理的代码执行流程切换，完全避免了死锁和阻塞等情况（执行带屏幕输出的

ring_greenlet.py我们会看到脚本总是一个一个地处理消息，把一个消息在环上从头传到尾之后，再开始处理下一个消息）。因为greenlet本质是串行，因此在没有进行显式切换时，代码的其他部分是无法被执行到的，如果要避免代码长时间占用运算资源造成程序假死，那么还是要将greenlet与线程/进程机制结合使用（每个线程、进程下都可以建立多个greenlet，但是跨线程/进程时greenlet 之间无法切换或通讯）。

Stackless则比较特别，对很多资源从底层进行了并发改造，并且提供了channel 等更适合“并发”的通讯机制实现，使得资源互斥冲突的可能性大大减小，并发性能自然得以提高。粗糙来讲，greenlet是“阻塞了我就先干点儿别的，但是程序员得明确告诉greenlet能先干点儿啥以及什么时候回来”；Stackless则是“东西我已经改造好了，你只要用我的东西，并发冲突就不用操心，只管放心大胆地并发好了”。greenlet应该是学习了Stackless的上下文切换机制，但是对底层资源没有进行适合并发的改造。并且实际上greenlet也没有必要改造底层资源的并发性，因为它本质是串行的单线程，不与其他并发模型混合使用的话是无法造成对资源的并发访问的。

(Edit Section ↓)

greenlet 封装后的eventlet 方案

eventlet 是基于greenlet 实现的面向网络应用的并发处理框架，提供“线程”池、队列等与其他Python 线程、进程模型非常相似的api，并且提供了对Python 发行版自带库及其他模块的超轻量并发适应性调整方法，比直接使用greenlet 要方便得多。并且这个解决方案源自著名虚拟现实游戏“第二人生”，可以说是久经考验的新兴并发处理模型。其基本原理是调整Python 的socket

调用，当发生阻塞时则切换到其他greenlet 执行，这样来保证资源的有效利用。需要注意的是：

?eventlet 提供的函数只能对Python 代码中的socket 调用进行处理，而不能对模块的 C 语言部分的socket 调用进行修改。对后者这类模块，仍然需要把调用模块的代码封装在Python 标准线程调用中，之后利用

eventlet 提供的适配器实现eventlet 与标准线程之间的协作。

?再有，虽然eventlet 把api 封装成了非常类似标准线程库的形式，但两者的实际并发执行流程仍然有明显区别。在没有出现I/O 阻塞时，除

非显式声明，否则当前正在执行的eventlet 永远不会把cpu 交给其他

的eventlet，而标准线程则是无论是否出现阻塞，总是由所有线程一起

争夺运行资源。所有eventlet 对I/O 阻塞无关的大运算量耗时操作基

本没有什么帮助。

在性能测试结果方面，eventlet 消耗的运行时间大致是greenlet 方案的 3 到5 倍，而Python 标准线程模型的thread 方式消耗的运行时间大致是eventlet 测试代码的8 到10 倍。其中前者可能是因为我们在eventlet 的测试代码中，使用队列机制来完成所有的消息传递，而队列上的访问互斥保护可能额外消耗了一些运算资源。总体而言，eventlet 模型的并发性能虽然比Stackless Python 和直接使用greenlet 有一定差距，但仍然比标准线程模型有大约一个数量级的优势，这也就不奇怪近期很多强调并发性能的网络服务器实现

实验代码下载：

?版本3 下载：增加了eventlet 方案的实验代码。

?版本2 下载：增加了greenlet 方案的实验代码。

?版本1 下载：包括Stackless Python 、thread 、threading 、processing 四种方案的实验代码。

为方便阅读，将实验中用到的几个脚本的代码粘贴如下，其中Stackless Python

方案的代码实现直接取自Erlang vs. Stackless python: a first benchmark：

(Edit Section ↓)

5.1 ring_no_io_slp.py

1.#!/Library/Frameworks/Python.framework/Versions/

2.5/

bin/python

2.# encoding: utf-8

3.import sys

4.import stackless as SL

5.

6.def run_benchmark(n, m):

7.# print(">> Python 2.5.1, stackless 3.1b3 here (N=%d,

M=%d)!\n" % (n, m))

8. firstP = cin = SL.channel()

9.for s in xrange(1, n):

10. seqn = s

11. cout = SL.channel()

12.# # print("*> s = %d" % (seqn, ))

13. t = SL.tasklet(loop)(seqn, cin, cout)

14. cin = cout

15.else:

16. seqn = s+1

17.# # print("$> s = %d" % (seqn, ))

18. t = SL.tasklet(mloop)(seqn, cin)

19.for r in xrange(m-1, -1, -1):

20.# # print("+ sending Msg# %d" % r)

21. firstP.send(r)

22. SL.schedule()

23.def loop(s, cin, cout):

24.while True:

25. r = cin.receive()

26. cout.send(r)

27.if r >0:

28.# print(": Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid(), s, r))

29.pass

30.else:

31.# print("* Proc: <%s>, Seq#: %s, Msg#:

terminate!" % (pid(), s))

32.break

33.def mloop(s, cin):

34.while True:

35. r = cin.receive()

36.if r >0:

37.# print("> Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid(), s, r))

38.pass

39.else:

40.# print("@ Proc: <%s>, Seq#: %s, ring

terminated." % (pid(), s))

41.break

42.

43.def pid(): return

repr(SL.getcurrent()).split()[-1][2:-1]

44.

45.if __name__ == '__main__':

46. run_benchmark(int(sys.argv[1]),

int(sys.argv[2]))

[Get Code] (Edit Section ↓)

5.2 ring_no_io_thread.py

1.#!/Library/Frameworks/Python.framework/Versions/

2.5/

bin/python

2.# encoding: utf-8

3.import sys, time

4.import thread

5.

6.SLEEP_TIME = 0.0001

7.

8.def run_benchmark(n, m):

9.# print(">> Python 2.5.1, stackless 3.1b3 here (N=%d,

M=%d)!\n" % (n, m))

10. locks = [thread.allocate_lock() for i in xrange(n)]

11. firstP = cin = []

12. cin_lock_id = 0

13.for s in xrange(1, n):

14. seqn = s

15. cout = []

16. cout_lock_id = s

17.# print("*> s = %d" % (seqn, ))

18.thread.start_new_thread(loop, (seqn, locks,

cin, cin_lock_id, cout, cout_lock_id))

19. cin = cout

20. cin_lock_id = cout_lock_id

21.else:

22. seqn = s+1

23.# print("$> s = %d" % (seqn, ))

24.thread.start_new_thread(mloop, (seqn, locks,

cin, cin_lock_id))

25.for r in xrange(m-1, -1, -1):

26.# print("+ sending Msg# %d" % r)

27. lock = locks[0]

28. lock.acquire()

29. firstP.append(r)

30. lock.release()

31.time.sleep(SLEEP_TIME)

32.try:

33.while True:

34.time.sleep(SLEEP_TIME)

35.except:

36.pass

37.def loop(s, locks, cin, cin_lock_id, cout,

cout_lock_id):

38.while True:

39. lock = locks[cin_lock_id]

40. lock.acquire()

41.if len(cin) >0:

42. r = cin.pop(0)

43. lock.release()

44.else:

45. lock.release()

46.time.sleep(SLEEP_TIME)

47.continue

48. lock = locks[cout_lock_id]

49. lock.acquire()

50. cout.append(r)

51. lock.release()

52.if r >0:

53.# print(": Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid(), s, r))

54.pass

55.else:

56.# print("* Proc: <%s>, Seq#: %s, Msg#:

terminate!" % (pid(), s))

57.break

58.def mloop(s, locks, cin, cin_lock_id):

59.while True:

60. lock = locks[cin_lock_id]

61. lock.acquire()

62.if len(cin) >0:

63. r = cin.pop(0)

64. lock.release()

65.else:

66. lock.release()

67.time.sleep(SLEEP_TIME)

68.continue

69.if r >0:

70.# print("> Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid(), s, r))

71.pass

72.else:

73.# print("@ Proc: <%s>, Seq#: %s, ring

terminated." % (pid(), s))

74.break

75.thread.interrupt_main()

76.

77.def pid(): return thread.get_ident()

78.

79.if __name__ == '__main__':

80. run_benchmark(int(sys.argv[1]),

int(sys.argv[2]))

[Get Code] (Edit Section ↓)

5.3 ring_no_io_queue.py

1.#!/Library/Frameworks/Python.framework/Versions/

2.5/

bin/python

2.# encoding: utf-8

3.import sys

4.import threading, Queue

5.

6.def run_benchmark(n, m):

7.# print(">> Python 2.5.1, stackless 3.1b3 here (N=%d,

M=%d)!\n" % (n, m))

8. firstP = cin = Queue.Queue()

9.for s in xrange(1, n):

10. seqn = s

11. cout = Queue.Queue()

12.# print("*> s = %d" % (seqn, ))

13. t = Loop(seqn, cin, cout)

14. t.setDaemon(False)

15. t.start()

16. cin = cout

17.else:

18. seqn = s+1

19.# print("$> s = %d" % (seqn, ))

20. t = MLoop(seqn, cin)

21. t.setDaemon(False)

22. t.start()

23.for r in xrange(m-1, -1, -1):

24.# print("+ sending Msg# %d" % r)

25. firstP.put(r)

26.class Loop(threading.Thread):

27.def__init__(self, s, cin, cout):

28.threading.Thread.__init__(self)

29.self.cin = cin

30.self.cout = cout

31.self.s = s

32.def run(self):

33.while True:

34. r = self.cin.get()

35.self.cout.put(r)

36.if r >0:

37.# print(": Proc: <%s>, Seq#: %s,

Msg#: %s .." % (pid(), self.s, r))

38.pass

39.else:

40.# print("* Proc: <%s>, Seq#: %s, Msg#:

terminate!" % (pid(), self.s))

41.break

42.class MLoop(threading.Thread):

43.def__init__(self, s, cin):

44.threading.Thread.__init__(self)

45.self.cin = cin

46.self.s = s

47.def run(self):

48.while True:

49. r = self.cin.get()

50.if r >0:

51.# print("> Proc: <%s>, Seq#: %s,

Msg#: %s .." % (pid(), self.s, r))

52.pass

53.else:

54.# print("@ Proc: <%s>, Seq#: %s, ring

terminated." % (pid(), self.s))

55.break

56.

57.def pid(): return threading.currentThread()

58.

59.if __name__ == '__main__':

60. run_benchmark(int(sys.argv[1]),

int(sys.argv[2]))

[Get Code] (Edit Section ↓)

5.4 ring_no_io_proc.py

1.#!/Library/Frameworks/Python.framework/Versions/

2.5/

bin/python

2.# encoding: utf-8

3.import sys

4.import processing, Queue

5.

6.def run_benchmark(n, m):

7.# print(">> Python 2.5.1, stackless 3.1b3 here (N=%d,

M=%d)!\n" % (n, m))

8. firstP = cin = processing.Queue()

9.for s in xrange(1, n):

10. seqn = s

11. cout = processing.Queue()

12.# print("*> s = %d" % (seqn, ))

13. p = processing.Process(target = loop, args =

[seqn, cin, cout])

14. p.start()

15. cin = cout

16.else:

17. seqn = s+1

18.# print("$> s = %d" % (seqn, ))

19. p = processing.Process(target = mloop, args =

[seqn, cin])

20. p.start()

21.for r in xrange(m-1, -1, -1):

22.# print("+ sending Msg# %d" % r)

23. firstP.put(r)

24. p.join()

25.def loop(s, cin, cout):

26.while True:

27. r = cin.get()

28. cout.put(r)

29.if r >0:

30.# print(": Proc: <%s>, Seq#: %s,

Msg#: %s .." % (pid(), s, r))

31.pass

32.else:

33.# print("* Proc: <%s>, Seq#: %s, Msg#:

terminate!" % (pid(), s))

34.break

35.def mloop(s, cin):

36.while True:

37. r = cin.get()

38.if r >0:

39.# print("> Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid(), s, r))

40.pass

41.else:

42.# print("@ Proc: <%s>, Seq#: %s, ring

terminated." % (pid(), s))

43.break

44.

45.def pid(): return processing.currentProcess()

46.

47.if __name__ == '__main__':

48. run_benchmark(int(sys.argv[1]),

int(sys.argv[2]))

[Get Code] (Edit Section ↓)

5.5 ring_no_io_greenlet.py

1.#!/Library/Frameworks/Python.framework/Versions/

2.5/

bin/python

2.# encoding: utf-8

3.import sys

4.from py.magic import greenlet

5.

6.def run_benchmark(n, m):

7.# print(">> Python 2.5.1, stackless 3.1b3 here (N=%d,

M=%d)!\n" % (n, m))

8. glets = [greenlet.getcurrent()]

9.for s in xrange(1, n):

10. seqn = s

11. glets.append(greenlet(loop))

12.# print("*> s = %d" % (seqn, ))

13.else:

14. seqn = s+1

15. glets.append(greenlet(mloop))

16.# print("$> s = %d" % (seqn, ))

17. glets[-1].switch(seqn, glets)

18.for r in xrange(m-1, -1, -1):

19.# print("+ sending Msg# %d" % r)

20. glets[1].switch(r)

21.def loop(s, glets):

22. previous = glets[s - 1]

23. next = glets[s + 1]

24.if s >1:

25. r = previous.switch(s - 1, glets)

26.else:

27. r = previous.switch()

28.while True:

29.if r >0:

30.# print(": Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid("loop", s), s, r))

31.pass

32.else:

33.# print("* Proc: <%s>, Seq#: %s, Msg#:

terminate!" % (pid("loop", s), s))

34.break

35. next.switch(r)

36. r = previous.switch()

37. next.switch(r)

38.def mloop(s, glets):

39. previous = glets[s - 1]

40. r = previous.switch(s - 1, glets)

41.while True:

42.if r >0:

43.# print("> Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid("mloop", s), s, r))

44.pass

45.else:

46.# print("@ Proc: <%s>, Seq#: %s, ring

terminated." % (pid("mloop", s), s))

47.break

48. r = previous.switch()

49.

50.def pid(func, s): return"<<%s(Greenlet-%d,

started)>>"% (func, s)

51.

52.if __name__ == '__main__':

53. run_benchmark(int(sys.argv[1]),

int(sys.argv[2]))

[Get Code] (Edit Section ↓)

5.6 ring_no_io_eventlet.py

1.#!/Library/Frameworks/Python.framework/Versions/

2.5/

bin/python

2.# encoding: utf-8

3.import sys

4.import eventlet

5.

6.def run_benchmark(n, m):

7.# print(">> Python 2.5.1, stackless 3.1b3 here (N=%d,

M=%d)!\n" % (n, m))

8. firstP = cin = eventlet.Queue()

9.for s in xrange(1, n):

10. seqn = s

11. cout = eventlet.Queue()

12.# print("*> s = %d" % (seqn, ))

13. eventlet.spawn_n(loop, seqn, cin, cout)

14. cin = cout

15.else:

16. seqn = s+1

17.# print("$> s = %d" % (seqn, ))

18.for r in xrange(m-1, -1, -1):

19.# print("+ sending Msg# %d" % r)

20. firstP.put(r)

21. mloop(seqn, cin)

22.def loop(s, cin, cout):

23.while True:

24. r = cin.get()

25. cout.put(r)

26.if r >0:

27.# print(": Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid(), s, r))

28.pass

29.else:

30.# print("* Proc: <%s>, Seq#: %s, Msg#:

terminate!" % (pid(), s))

31.break

32.def mloop(s, cin):

33.while True:

34. r = cin.get()

35.if r >0:

36.# print("> Proc: <%s>, Seq#: %s, Msg#: %s .." %

(pid(), s, r))

37.pass

38.else:

39.# print("@ Proc: <%s>, Seq#: %s, ring

terminated." % (pid(), s))

40.break

41.

42.def pid(): return eventlet.greenthread.getcurrent()

43.

44.if __name__ == '__main__':

45. run_benchmark(int(sys.argv[1]),

int(sys.argv[2]))

Python实例应用

Python实例应用 她——一种最初由Guido van Rossum开发的开源(Open Source)的脚本语言。 Python已经有10年的历史了，在国外十分盛行。 Google搜索引擎的脚本，现在流行的BT(Bite Torrnet)，还有著名的应用服务器Zope都是用Python编写的。但在国内的使用还不是很多。她十分有自己的特色。语法简洁，但功能强大，可以跨平台使用，在Linux、Windows和Mac上都有很好支持。她的设计很出色。 这里有两个Python的使用例子，都是对磁盘文件的操作，以次来看看Python 的特色。以下的程序是在 Windows平台上完成的。在Windows上安装Python十分方便，到Python的官方站点(https://www.sodocs.net/doc/758970197.html,)可以免费下载 Windows平台上的二进制安装包后直接安装就可以了，安装程序会完成所有的配置，不用象Java 一样要自己设置环境变量。 情景一： 在文件夹里有六十多个RM格式的视频文件，我现在需要把它们的文件名都提取出来，并去掉文件的扩展名，以便放到需要的网页里。 应该有什么软件可以完成这个简单的要求，可是一时间到哪里去找这样一个符合要求的软件呢？总不能手工完成把。在Linux上用强大的shell脚本应该也可以完成，可是使用Windows的朋友呢？其实象这样一个简单任务用Python这个强大脚本语言只要几条语句就可以搞定了。个大家知道，要完成这样一个任务根本不用动用C/C++或Java这样的大家伙。 好来看看Python的身手，用自己喜欢的文本编辑器或者直接使用安装包自带的IDE都可以： # --- picknames.py --- import os filenames=os.listdir(os.getcwd()) for name in filenames: filenames[filenames.index(name)]=name[:-3] out=open('names.txt','w') for name in filenames: out.write(name+'\n') out.close() 句字不多，一句句看。

Python的应用领域有哪些

Python的应用领域有哪些？ Python是一门简单、易学并且很有前途的编程语言，很多人都对Python感兴趣，但是当学完Python基础用法之后，又会产生迷茫，尤其是自学的人员，不知道接下来的Python学习方向，以及学完之后能干些什么？以下是Python十大应用领域！ 1. WEB开发 Python拥有很多免费数据函数库、免费web网页模板系统、以及与web服务器进行交互的库，可以实现web开发，搭建web框架，目前比较有名气的Python web框架为Django。从事该领域应从数据、组件、安全等多领域进行学习，从底层了解其工作原理并可驾驭任何业内主流的Web框架。 2. 网络编程 网络编程是Python学习的另一方向，网络编程在生活和开发中无处不在，哪里有通讯就有网络，它可以称为是一切开发的“基石”。对于所有编程开发人员必须要知其然并知其所以然，所以网络部分将从协议、封包、解包等底层进行深入剖析。 3. 爬虫开发 在爬虫领域，Python几乎是霸主地位，将网络一切数据作为资源，通过自动化程序进行有针对性的数据采集以及处理。从事该领域应学习爬虫策略、高性能异步IO、分布式爬虫等，并针对Scrapy框架源码进行深入剖析，从而理解其原理并实现自定义爬虫框架。 4. 云计算开发 Python是从事云计算工作需要掌握的一门编程语言，目前很火的云计算框架OpenStack就是由Python开发的，如果想要深入学习并进行二次开发，就需要具备Python 的技能。

5. 人工智能 MASA和Google早期大量使用Python，为Python积累了丰富的科学运算库，当AI 时代来临后，Python从众多编程语言中脱颖而出，各种人工智能算法都基于Python编写，尤其PyTorch之后，Python作为AI时代头牌语言的位置基本确定。 6. 自动化运维 Python是一门综合性的语言，能满足绝大部分自动化运维需求，前端和后端都可以做，从事该领域，应从设计层面、框架选择、灵活性、扩展性、故障处理、以及如何优化等层面进行学习。 7. 金融分析 金融分析包含金融知识和Python相关模块的学习，学习内容囊括Numpy\Pandas\Scipy数据分析模块等，以及常见金融分析策略如“双均线”、“周规则交易”、“羊驼策略”、“Dual Thrust 交易策略”等。 8. 科学运算 Python是一门很适合做科学计算的编程语言，97年开始，NASA就大量使用Python 进行各种复杂的科学运算，随着NumPy、SciPy、Matplotlib、Enthought librarys等众多程序库的开发，使得Python越来越适合做科学计算、绘制高质量的2D和3D图像。 9. 游戏开发 在网络游戏开发中，Python也有很多应用，相比于Lua or C++，Python比Lua有更高阶的抽象能力，可以用更少的代码描述游戏业务逻辑，Python非常适合编写1万行以上的项目，而且能够很好的把网游项目的规模控制在10万行代码以内。 10. 桌面软件 Python在图形界面开发上很强大，可以用tkinter/PyQT框架开发各种桌面软件！

第十三课人生苦短我用Python语法简单才会越来越被编程界欢迎

第十三课人生苦短我用Python语法简单才会越来越被编程界欢迎初始函数 1.1 函数的作用 ;1.2函数的组成 1.3定义和调用函数 函数的进阶使用 2.1函数类型 2.2返回多个值 多函数协作 3.1变量作用域 3.2函数嵌 /\e这两节课的主要内容是带大家探究“熟悉的陌生人”——函数。之所以这么说，是因 为我们之前已经接触过Python函数，但是对它没有系统地了解过。这节课，我们一起经营KFC，在我们KFC门店里通过运用函数解决我们的问题。首先在学习具体知识前，我向大家简 要的介绍下函数的作用，知道函数是做什么用的？ 1 函数的作用 人生苦短，我用Python”，正因为Python语法简单，才会越来越被编程界欢迎。换言之，我们编程，更应该避免重复性代码。前面学习的循环是减少代码重复的一种手段，那么接下来要学习的函数也是减少重复性代码的另一种手段。它的定义是：

什么意思呢？我们之前写的代码只能执行一次，但是函数中的代码可以使用多次。通俗来讲，函数就如同一个包裹，每个包裹都有一个功能，无论你在哪儿，只要你需要包裹，就把它拿过去用；你需要什么样功能的包裹，就用什么样的包裹；你需要使用多少次包裹，就使用多少次。这就是函数，在之后的旅程中，你会越来越体会到函数的妙用。讲了这么多了，先看一下函数长什么样子？ 1.2函数的组成 先不着急看Python的函数，先来个数学函数，那些年，我们错过的函数。数学函数y = 6*x +9 ， x是自变量，6*x+9是执行过程，y是因变量，自变量x决定了因变量y得值。那么，你可以将y = 6*x +9看作成3部分 在Python中，我们遇到很多函数，有负责输入数据的函数，有负责数据处理的函数，有负责数据输出的函数。 以上就是我们见过的Python的函数，这些函数是Python自带的函数，我们不需要管这些函数怎么来的，就负责用就好了，这些函数也叫内置函数。你会发现，上面这些函数，都有括号（），里面存放我们需要传给函数的数据，在Python江湖中，这种数据称为【函数的参数】。【参数】指的是函数要接受、处理的数据，其实就是一个变量。

Python学习之Python应用领域介绍(一)

Python学习之Python应用领域介绍（一） 最近Python这个词可是在我们的生活里火了，无论是朋友圈还是身边的人，几乎所有人都知道Python，那Python到底有多大魅力呢，今天我们就从Python的一方面来分析，就是Python的应用领域有哪些。 下面就让我们一起来看看它的强大功能： Python（派森），它是一个简单的、解释型的、交互式的、可移植的、面向对象的超高级语言。这就是对Python语言的最简单的描述。 Python有一个交互式的开发环境，因为Python是解释运行，这大大节省了每次编译的时间。Python语法简单，且内置有几种高级数据结构，如字典、列表等，使得使用起来特别简单，程序员一个下午就可学会，一般人员一周内也可掌握。Python具有大部分面向对象语言的特征，可完全进行面向对象编程。它可以在MS-DOS、Windows、Windows NT、Linux、Soloris、Amiga、BeOS、OS/2、VMS、QNX等多种OS上运行。

编程语言 Python语言可以用来作为批处理语言，写一些简单工具，处理些数据，作为其他软件的接口调试等。Python语言可以用来作为函数语言，进行人工智能程序的开发，具有Lisp语言的大部分功能。Python语言可以用来作为过程语言，进行我们常见的应用程序开发，可以和VB等语言一样应用。Python 语言可以用来作为面向对象语言，具有大部分面向对象语言的特征，常作为大型应用软件的原型开发，再用C++改写，有些直接用Python来开发。 数据库 Python在数据库方面也很优秀，可以和多种数据库进行连接，进行数据处理，从商业型的数据库到开放源码的数据库都提供支持。例如：Oracle,Ms SQL Server等等。有多种接口可以与数据库进行连接，至少包括ODBC。有许多公司采用着Python＋MySql的架构。因此，掌握了Python使你可以充分利用面向对象的特点，在数据库处理方面如虎添翼。

Python简单指导应用题

1.使用turtle 库绘制轮廓颜色为红色（red）、填充颜色为粉红色（pink）的心形图形，效果如下图所示。阅读程序框架，补充横线处代码。 from turtle import * color('red', ____①____) (____②____) left(135) fd(100) right(180) circle(50, –180) left(90) circle(50, –180) right(180) fd(100) end_fill() hideturtle() done() 输出 参考代码： from turtle import *

color('red','pink') begin_fill() left(135) fd(100) right(180) circle(50,-180) left(90) circle(50,-180) right(180) fd(100) end_fill() hideturtle() done() 2.使用turtle 库绘制红色五角星图形，效果如下图所示。阅读程序框架，补充横线处代码。(____①____) setup(400,400) penup() goto(–100,50) pendown() color("red") begin_fill() for i in range(5): forward(200) (____②____) end_fill()

hideturtle() done() 输出 参考代码： from turtle import * setup(400,400) penup() goto(-100,50) pendown() color("red") begin_fill() for i in range(5): forward(200) right(144) end_fill() hideturtle() done() 3. 使用turtle 库绘制正方形螺旋线，效果如下图所示。阅读程序框架，补充横线处代码。import turtle n = 10

Python简单应用题

1.使用 turtle 库绘制轮廓颜色为红色（red）、填充颜色为粉红色（pink）的心形图形，效果如下图所示。阅读程序框架，补充横线处代码。 from turtle import * color('red', ____①____) (____②____) left(135) fd(100) right(180) circle(50, –180) left(90) circle(50, –180) right(180) fd(100) end_fill() hideturtle() done() 输出 参考代码： from turtle import * color('red','pink') begin_fill() left(135) fd(100) right(180) circle(50,-180) left(90) circle(50,-180) right(180) fd(100) end_fill() hideturtle() done() 2.使用 turtle 库绘制红色五角星图形，效果如下图所示。阅读程序框架，补充横线处代码。(____①____)

setup(400,400) penup() goto(–100,50) pendown() color("red") begin_fill() for i in range(5): forward(200) (____②____) end_fill() hideturtle() done() 输出 参考代码： from turtle import * setup(400,400) penup() goto(-100,50) pendown() color("red") begin_fill() for i in range(5): forward(200) right(144) end_fill() hideturtle() done() 3. 使用 turtle 库绘制正方形螺旋线，效果如下图所示。阅读程序框架，补充横线处代码。 import turtle n = 10 for i in range(1,10,1): for j in [90,180,–90,0]: (____①____) (____②____) n += 5

用python写的简单病毒(无害)资料

计算机病毒 实验报告 姓名：郭莎莎学号： 201306043023 培养类型：技术类年级： 2013级 专业：信息安全所属学院：计算机学院 指导教员：龙军职称：教授 实验室：实验日期： 2016.7.3 国防科学技术大学训练部制

《本科实验报告》填写说明 1．学员完成人才培养方案和课程标准要所要求的每个实验后，均须提交实验报告。 2．实验报告封面必须打印，报告内容可以手写或打印。 3．实验报告内容编排及打印应符合以下要求： （1）采用A4（21cm×29.7cm）白色复印纸，单面黑字打印。上下左右各侧的页边距均为3cm；缺省文档网格：字号为小4号，中文为宋体，英文和阿拉伯数字为Times New Roman，每页30行，每行36字；页脚距边界为2.5cm，页码置于页脚、居中，采用小5号阿拉伯数字从1开始连续编排，封面不编页码。 （2）报告正文最多可设四级标题，字体均为黑体，第一级标题字号为3号，其余各级标题为4号；标题序号第一级用“一、”、“二、”……，第二级用“（一）”、“（二）” ……，第三级用“1.”、“2.”……，第四级用“（1）”、“（2）” ……，分别按序连续编排。 （3）正文插图、表格中的文字字号均为5号。

实验题目 Python病毒功能实现 目录 一、实验目的 (4) 二、实验内容 (4) 三、实验原理 (4) （一）Linux病毒 (4) 1.Linux病毒的发展史 (4) 2.Linux平台下的病毒分类 (5) （二）文件型病毒 (6) 1.感染COM文件： (6) 2．感染EXE文件： (6) （三）python文件 (7) 四、实验所需软硬件 (8) 五、实验步骤 (8) （一）程序框架 (8) 1.传播感染模块 (8) 2.备份模块 (9) 3.触发和破坏模块 (9) （二）具体实现 (9) （三）结果截屏 (11) 六、实验结果与分析 (12) 七、思考与总结 (12)

python基础语法

Python的特点 1. 简单 Python是一种代表简单思想的语言。 2. 易学 Python有极其简单的语法。 3. 免费、开源 Python是FLOSS（自由/开放源码软件）之一。 4. 高层语言 使用Python编写程序时无需考虑如何管理程序使用的内存一类的底层细节。 5. 可移植性

Python已被移植到很多平台，这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、 BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、 Windows CE甚至还有PocketPC。 6. 解释性 可以直接从源代码运行。在计算机内部，python解释器把源代码转换为字节码的中间形式，然后再把它翻译成计算机使用的机器语言。 7. 面向对象 Python既支持面向过程编程也支持面向对象编程。 8. 可扩展性

部分程序可以使用其他语言编写，如c/c++。 9. 可嵌入型 可以把Python嵌入到c/c++程序中，从而提供脚本功能。 10. 丰富的库 Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、 电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk 和其他与系统有关的操作。 ---------------分割线------------------------以下是Python的基本语法--------------------------------------------------------- 一、基本概念

从零开始：写一个简单的Python框架

你为什么想搭建一个Web框架？我想有下面几个原因： 有一个新奇的想法，将会取代其他框架。 获得一些疯狂的街头信誉。 你的问题比较独特，现有的框架不适合。 你想成为一位更好的Web开发者，你对Web框架是如何运行的感到好奇。 我将集中精力在最后一点上。这篇文章旨在描述我从写一个小型的服务框架中学到了什么，我将解释框架的设计，以及如何一步一步，一个函数一个函数的实现这个框架的。关于此项目完整的代码可以点击此链接。 我希望我的行为可以鼓励大家去尝试因为真的非常有趣，我们可以从中学到很多关于web 应用程序是如何工作的知识，而且比我想象的要容易的多。 范围 框架的功能有：请求-响应周期、身份验证、数据库访问、模板的生成等。Web开发者使用框架，因为大多数Web应用程序共享大量的相同功能，并且没必要为每个项目都重新实现这些功能。 像Rails或Django这些较大的框架做了高层次的抽象并且功能完备。这些框架经历了很长时间来完成所有这些特性，因此，我们重点完成一个微型框架。开始写代码前，我先列一下这个微型框架的功能及一些限制。 功能： 可以处理GET和POST的HTTP请求。从该WIKI中你可以了解获得关于HTTP简介。 异步的（我喜欢Python3 asyncio这个模块）。 包含简单的路由逻辑，以及参数捕获。 像其他酷的微框架一样，提供简单的用户级API。 可以处理身份验证，因为学会会非常的酷（在第2部分介绍）。 限制：

仅完成HTTP/1.1协议的一小部分：不实现transfer-encoding, http-auth, content-encoding (gzip), persistant connections（持久连接）这些功能。 响应信息中无MIME-guessing，用户将不得不手动设置。 无WSGI-只是简单的TCP连接处理。 不支持数据库。 我决定用一个小的用例来使上面的需求更具体，同样可以演示这个框架的API： 用户应该能够定义几个异步函数返回字符串或响应对象，然后用表示路由的字符串与这些函数配对，最后通过一个函数调用（start_server）开始处理请求。 有了这些设计后，我需要编码来实现这些抽象： 一个可以接受TCP连接和进度的异步函数。

Python简单应用题

1、使用turtle 库绘制轮廓颜色为红色(red)、填充颜色为粉红色(pink)的心形图形,效果如下图所示。阅读程序框架,补充横线处代码。 from turtle import * color('red', ____①____) (____②____) left(135) fd(100) right(180) circle(50, –180) left(90) circle(50, –180) right(180) fd(100) end_fill() hideturtle() done() 输出 参考代码: from turtle import * color('red','pink') begin_fill() left(135) fd(100) right(180) circle(50,-180) left(90) circle(50,-180) right(180) fd(100) end_fill() hideturtle() done() 2、使用turtle 库绘制红色五角星图形,效果如下图所示。阅读程序框架,补充横线处代码。(____①____)

setup(400,400) penup() goto(–100,50) pendown() color("red") begin_fill() for i in range(5): forward(200) (____②____) end_fill() hideturtle() done() 输出 参考代码: from turtle import * setup(400,400) penup() goto(-100,50) pendown() color("red") begin_fill() for i in range(5): forward(200) right(144) end_fill() hideturtle() done() 3、使用turtle 库绘制正方形螺旋线,效果如下图所示。阅读程序框架,补充横线处代码。import turtle n = 10 for i in range(1,10,1): for j in [90,180,–90,0]: turtle、seth (____①____) turtle、fd(____②____) n += 5 输出

Python入门教程 超详细1小时学会Python

创作编号：BG7531400019813488897SX 创作者：别如克* Python入门教程超详细1小时学会Python 为什么使用Python 假设我们有这么一项任务:简单测试局域网中的电脑是否连通.这些电脑的ip 范围从192.168.0.101到192.168.0.200. 思路:用shell编程.(Linux通常是bash而Windows是批处理脚本).例如,在Windows上用ping ip 的命令依次测试各个机器并得到控制台输出.由于ping通的时候控制台文本通常是"Reply from ... " 而不通的时候文本是"time out ... " ,所以,在结果中进行字符串查找,即可知道该机器是否连通. 实现:Java代码如下: String cmd="cmd.exe ping "; String ipprefix="192.168.10."; int begin=101; int end=200; Process p=null; for(int i=begin;i

nputStream())); while((line = reader.readLine()) != null) { //Handling line , may logs it. } reader.close(); p.destroy(); } 这段代码运行得很好,问题是为了运行这段代码,你还需要做一些额外的工作.这些额外的工作包括: 1.编写一个类文件 2.编写一个main方法 3.将之编译成字节代码 4.由于字节代码不能直接运行,你需要再写个小小的bat或者bash脚本来运行. 当然,用C/C++同样能完成这项工作.但C/C++不是跨平台语言.在这个足够简单的例子中也许看不出C/C++和Java实现的区别,但在一些更为复杂的场景,比如要将连通与否的信息记录到网络数据库.由于Linux和Windows的网络接口实现方式不同,你不得不写两个函数的版本.用Java就没有这样的顾虑. 同样的工作用Python实现如下: import subprocess cmd="cmd.exe" begin=101 end=200 while begin

Python 简单应用

实验三Python简单应用 一、实验目的 1）熟悉Python开发环境； 2）掌握简单程序的编写； 3）掌握Python命令行与程序运行方式。 二、实验内容 1）算法的描述工具； 2）排序算法应用； 3）Python程序的调试与运行。 三、预备知识 1.算法的描述工具 1）用自然语言描述算法； 2）用流程图描述算法； 3）用N-S图描述算法； 4）用伪代码描述算法 5）用计算机程序表述算法。 2.排序算法应用 1）选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 2）赋值语句（=）； 3）输出语句print，可以用格式符控制输出样式，print“格式字符串”%(data1,data2,……)其中，%左边部分的“格式字符串”包含普通字符串和%开头的特殊字符序列，如%d表示输出十进制整数，“%f”表示浮点型型数据的输出等。 4）输入函数input()或raw_input()。 5）自定义函数def 6)最小数据的下标用变量index表达。 4.循环结构 1）for语句，基本格式： for控制变量in可遍历的表达式： 循环体 2）while语句 while表达式: 循环体 5.函数应用 自定义函数格式： def函数名(参数列表): 函数体 6.排序算法

def selSort(nums): n=len(nums) for index in range(n-1): k=index for i in range(index+1,n): if nums[i]big: big=num print"The biggest number is:",big; 2）启动Python的IDLE环境，选择“File/New File”命令，输入上述代码，选择“File/Save”命令保存文件，输入文件名nums.py，默认文件扩展名为.py； 3）执行程序：选择“Run/Run Module”命令，解释并执行该程序，运行结果如图所示；

使_用python开发windows应用程序

本人以前一直用的是C++,MFC，毕业到了公司以后，公司用python做流程，我顺便最近研究了一下用python开发 windows应用程序的整个流程，大体如下： 一、开发前期准备 1.boa-constructor-0.6.1.bin.setup.exe #一个wxWidges的集成开发环境，简单如Delphi，可以直接拖拽控件，并且和其他集成环境不一样， #它不与集成开发环境的MainLoop冲突，用pythonwin,pyScripter都会冲突，典型报错就是运行第二次 #程序的时候，直接导致集成开发环境的强制退出，因为MainLoop冲突了 2.wxPython2.8-win32-unicode-2.8.10.1-py26.exe #wxPython库，提供了用C++写的windows组件库wx 3.py2exe-0.6.9.win32-py2.6.exe #打包发布工具，将python写的windows程序或控制台程序直接打包成exe可执行文件，供用户使用 上述三个软件都是基于python2.6的，软件版本一定要配套，因为他们默认的安装路径和python版本有关系，否则会找不到相关库的存在。 二、开发 软件安装完以后，打开BOA，哇塞，拖控件真简单，而且属性啥的和Dephi差不多，你只要改改属性，代码会自动生成，它生成的控件很漂亮，记得以前用 C++6.0开发软件的时候，那个控件真丑，都需要我重新用控件库去绑定优化，现在不用了~BOA生成的控件，视觉效果相当好~开发软件速度相当快，再也 不用为了软件界面而写太多代码，也不用为了生成一个小程序而生成了很多的文件，python开发的程序，没有多余的文件，而且文件很小。 三、发布 很多人都想在自己的软件程序写好以后，发布给其他人使用，一方面不希望自己的代码泄露，一方面以此显出一点成就感，呵呵，可以使用py2exe将你的

《Python程序设计》习题与答案

《Python 程序设计》习题与参考答案 第1章基础知识 1.1简单说明如何选择正确的Python版本。 答： 在选择Python的时候，一定要先考虑清楚自己学习Python的目的是什么，打算做哪方面的开发，有哪些扩展库可用，这些扩展库最高反复安装和卸载上。同时还应该注意，当更新的Python版本推岀之后，不要急于更 新，而是应该等确定自己所必须使用的扩展库也推岀了较新版本之后再进行更新。 尽管如此，Python 3毕竟是大势所趋，如果您暂时还没想到要做什么行业领域的应用开发，或者仅仅是为 了尝试一种新的、好玩的语言，那么请毫不犹豫地选择Python 3.x系列的最高版本(目前是Python 343 )。 1.2为什么说Python采用的是基于值的内存管理模式？ 答： Python采用的是基于值的内存管理方式，如果为不同变量赋值相同值，则在内存中只有一份该值，多个变量指向同一块内存地址，例如下面的代码。 >>> x = 3 >>> id(x) >>> y = 3 >>> id(y) >>> y = 5 >>> id(y) >>> id(x) 1.3在Python中导入模块中的对象有哪几种方式？ 答：常用的有三种方式，分别为 import模块名［as别名］ from 模块名import对象名［as别名］ from math import * 1.4使用pip命令安装numpy、scipy模块。 答：在命令提示符环境下执行下面的命令： pip in stall n umpy pip in stall scipy

1.5编写程序，用户输入一个三位以上的整数，输岀其百位以上的数字。例如用户输入1234，则程序输岀12。(提示：使用整除运算。) 答： x = in put('Please in put an in teger of more tha n 3 digits:') try: x = in t(x) x = x//100 if x == 0: pri nt('You must in put an in teger of more tha n 3 digits.') else: pri nt(x) except BaseExcepti on: prin t('You must in put an in teger.') import types x = in put('Please in put an in teger of more tha n 3 digits:') if type(x) != types .In tType: print 'You must in put an in teger.' elif le n( str(x)) != 4: print 'You must in put an in teger of more tha n 3 digits.' else: print x//100 第2章Python数据结构 2.1为什么应尽量从列表的尾部进行元素的增加与删除操作？ 答： 当列表增加或删除元素时，列表对象自动进行内存扩展或收缩，从而保证元素之间没有缝隙，但这涉及到 列表元素的移动，效率较低，应尽量从列表尾部进行元素的增加与删除操作以提高处理速度。 2.2编写程序，生成包含1000个0到100之间的随机整数，并统计每个元素的岀现次数。(提示：使用集 合。) 答： import ran dom x = [ran dom.ra ndin t(0,100) for i in ran ge(1000)] d = set(x) for v in d: prin t(v, ':', x.cou nt(v)) import ran dom x = [ran dom.ra ndin t(0,100) for i in ran ge(1000)] d = set(x)

python简单推荐系统(含完整代码)

似乎咱的产品七，八年前就想做个推荐系统的，就是类似根据用户的喜好，自动的找到用户喜欢的电影或者节目，给用户做推荐。可是这么多年过去了，不知道是领导忘记了还是怎么了，连个影子还没见到。 而市场上各种产品的都有了推荐系统了。比如常见的各种购物网站京东，亚马逊，淘宝之类的商品推荐，视频网站优酷的的类似影片推荐，豆瓣音乐的音乐推荐…… 一个好的推荐系统推荐的精度必然很高，能够真的发现用户的潜在需求或喜好，提高购物网詀的销量，让视频网站发现用户喜欢的收费电影…可是要实现一个高精度的推荐系统不是那么容易的，netflix曾经悬赏高额奖金寻找能给其推荐系统的精确度提高10%的人，可见各个公司对推荐系统的重视和一个好的推荐系统确实能带来经济效益。 下面咱以电影电视的推荐系统为例，一步一步的来实现一个简单的推荐系统吧,由于比较简单，整个推荐系统源码不到100行，大概70-80行吧，应该很容易掌握。为了快速开发原型，咱采用Python代码来演示 1.推荐系统的第一步，需要想办法收集信息 不同的业务，不同的推荐系统需要收集的信息不一样针对咱要做的电影推荐，自然是每个用户对自己看过的电影的评价了，如下图所示: Kai Zhou对Friends打分是4分，对Bedtime Stories打分是3分，没有对RoboCop 打分Shuai Ge没有对Friends打分，对Bedtime Stories打分是3.5分……为简单，咱将此数据存成csv文件，形成一个二维的矩阵，假设存在D:\train.csv，数据如下： Name,Friends,Bedtime Stories,Dawn of the Planet of the Apes,RoboCop,Fargo,Cougar Town Kai Zhou,4,3,5,,1,2Shuai Ge,,3.5,3,4,2.5,4.5 Mei Nv,3,4,2,3,2,3xiaoxianrou,2.5,3.5,3,3.5,2.5,3fengzhi,3,4,,5,3.5,3mein v,,4.5,,4,1,mincat,3,3.5,1.5,5,3.5,3alex,2.5,3,,3.5,,4 先从csv文件中加载二维矩阵，代码如下： def load_matrix(): matrix={}

Python之SQLite数据库应用简单应用与讲解

Python与SQLite数据库应用系统 --Python之SQLite数据库应用 作者：XX （XXXX学院，班级:XX班） 摘要：Python自带一个轻量级的关系型数据库SQLite。这一数据库使用SQL语言。SQLite作为后端数据库，可以制作有数据存储需求的工具。Python标准库中的sqlite3提供该数据库的接口。现在作为初学者，我将进行初步的尝试与应用。 关键字：Python；SQLite；应用；数据库；编程 一·Python与SQLite数据库关系学习初步 作为新时代的大学生学会使用网络查询相关信息非常重要，现在经过初步的网络学习以及书籍查询，现在整理如下： （一）创建数据库 注：全文学习范例将以一个简单的关系型数据库为实例，为一个书店存储书的分类和价格。数据库中包含两个表：category用于记录分类，book用于记录某个书的信息。一本书归属于某一个分类，因此book 有一个外键(foreign key)，指向catogory表的主键id。 (一)导入Python SQLITE数据库模块 Python2.5之后，内置了SQLite3，成为了内置模块，这给我们省了安装的功夫，只需导入即可~ 在调用connect函数的时候，指定库名称，如果指定的数据库存在就直接打开这个数据库，如果不存在就新创建一个再打开。也可以创建数据库在内存中。 在使用connect()连接数据库后，我就可以通过定位指针cursor，来执行SQL命令：import sqlite3

# test.db is a file in the working directory. conn = sqlite3.connect("test.db") c = conn.cursor() # create tables c.execute('''CREATE TABLE category (id int primary key, sort int, name text)''') c.execute('''CREATE TABLE book (id int primary key, sort int, name text, price real, category int, FOREIGN KEY (category) REFERENCES category(id))''') # save the changes https://www.sodocs.net/doc/758970197.html,mit() # close the connection with the database conn.close() SQLite的数据库是一个磁盘上的文件，如上面的test.db，因此整个数据库可以方便的移动或复制。test.db一开始不存在，所以SQLite将自动创建一个新文件。 利用execute()命令，我们执行了两个SQL命令，创建数据库中的两个表。创建完成后，保存并断开数据库连接。 （二）插入数据 上面创建了数据库和表，确立了数据库的抽象结构。下面将在同一数据库中插入数据： import sqlite3 conn = sqlite3.connect("test.db")

12岁的少年教你用Python做小游戏

你有没有想过电脑游戏是怎样制作出来的？其实它没有你想象的那样复杂！在这个教程里，你要学做一个叫《兔子和獾》的塔防游戏，兔子作为英雄，需要在城堡里抵御獾的进攻。 为了写这个游戏的代码，你将会用Python。好吧，我不是指一条大蟒蛇！Python是一种计算机语言。我们在这篇教程里选择Python是因为这门语言很容易上手，学习起来也很简单和有趣。 如果你是个Python方面的新手，在开始看教程之前你可以看看这本书《Think P ython: How to Think Like a Computer Scientist》。这能让你看教程的时候不那么吃力。 在看了那本书后回到这里并且准备好——兔子和獾之间有一场大战爆发，一起来加入到这场战斗中来吧！

1 2 3 4 Python 2.7.3 (v2.7.3:70274d53c1dd, Apr 9 2012, 20:52:43) [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> 注意：如果你想迅速终止Python，你可以输入exit()然后按回车，或者是按Contr ol+D。 现在很迅速的把Python环境配置好了，为了测试下Python是否正常工作，输入print 1+1 然后按回车，应该会打印出2。你刚才就写了一个简单的Python程序！

1 Python 2.7. 2 (default, Jun 20 2012, 16:23:33)

《Python程序设计基础》习题答案与分析

Python程序设计基础习题答案与分析 程昱

第1章基础知识 1.1 简单说明如何选择正确的Python版本。 答： 在选择Python的时候，一定要先考虑清楚自己学习Python的目的是什么，打算做哪方面的开发，有哪些扩展库可用，这些扩展库最高支持哪个版本的Python，是Python 2.x还是Python 3.x，最高支持到Python 2.7.6还是Python 2.7.9。这些问题都确定以后，再做出自己的选择，这样才能事半功倍，而不至于把大量时间浪费在Python的反复安装和卸载上。同时还应该注意，当更新的Python版本推出之后，不要急于更新，而是应该等确定自己所必须使用的扩展库也推出了较新版本之后再进行更新。 尽管如此，Python 3毕竟是大势所趋，如果您暂时还没想到要做什么行业领域的应用开发，或者仅仅是为了尝试一种新的、好玩的语言，那么请毫不犹豫地选择Python 3.x系列的最高版本（目前是Python 3.4.3）。 1.2 为什么说Python采用的是基于值的内存管理模式？ Python采用的是基于值的内存管理方式，如果为不同变量赋值相同值，则在内存中只有一份该值，多个变量指向同一块内存地址，例如下面的代码。 >>> x = 3 >>> id(x) 10417624 >>> y = 3 >>> id(y) 10417624 >>> y = 5 >>> id(y) 10417600 >>> id(x) 10417624 >>> x = [1, 2, 3, 1, 1, 2] >>> id(x[0])==id(x[3])==id(x[4]) True 1.3 解释Python中的运算符“/”和“//”的区别。 答： 在Python 2.x中，“/”为普通除法，当两个数值对象进行除法运算时，最终结果的精度与操作数中精度最高的一致；在Python 3.x中，“/”为真除法，与除法的数学含义一致。