python多对多
① python + django 多表联合查询方法求教
先让我们回忆一下在第五章里的关于书本(book)的数据模型：
1
from django.db import models
class Publisher(models.Model):
name = models.CharField(max_length=30)
address = models.CharField(max_length=50)
city = models.CharField(max_length=60)
state_province = models.CharField(max_length=30)
country = models.CharField(max_length=50)
website = models.URLField()
def __unicode__(self):
return self.name
class Author(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=40)
email = models.EmailField()
def __unicode__(self):
return u'%s %s' % (self.first_name, self.last_name)
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
def __unicode__(self):
return self.title
如我们在第5章的讲解,获取数据库对象的特定字段的值只需直接使用属性。 例如,要确定ID为50的书本的标题,我们这样做:
>>> from mysite.books.models import Book
>>> b = Book.objects.get(id=50)
>>> b.title
u'The Django Book'
但是,在之前有一件我们没提及到的是表现为ForeignKey 或 ManyToManyField的关联对象字段,它们的作用稍有不同。
访问外键(Foreign Key)值
当你获取一个ForeignKey 字段时,你会得到相关的数据模型对象。 例如:
>>> b = Book.objects.get(id=50)
>>> b.publisher
<Publisher: Apress Publishing>
>>> b.publisher.website
u'http://www.apress.com/'
对于用`` ForeignKey``
来定义的关系来说，在关系的另一端也能反向的追溯回来，只不过由于不对称性的关系而稍有不同。 通过一个`` publisher`` 对象，直接获取
books ，用 publisher.book_set.all() ，如下：
>>> p = Publisher.objects.get(name='Apress Publishing')
>>> p.book_set.all()
[<Book: The Django Book>, <Book: Dive Into Python>, ...]
实际上，book_set 只是一个 QuerySet（参考第5章的介绍），所以它可以像QuerySet一样,能实现数据过滤和分切，例如：
1
>>> p = Publisher.objects.get(name='Apress Publishing')
>>> p.book_set.filter(name__icontains='django')
[<Book: The Django Book>, <Book: Pro Django>]
属性名称book_set是由模型名称的小写(如book)加_set组成的。
访问多对多值(Many-to-Many Values)
多对多和外键工作方式相同，只不过我们处理的是QuerySet而不是模型实例。 例如,这里是如何查看书籍的作者：
>>> b = Book.objects.get(id=50)
>>> b.authors.all()
[<Author: Adrian Holovaty>, <Author: Jacob Kaplan-Moss>]
>>> b.authors.filter(first_name='Adrian')
[<Author: Adrian Holovaty>]
>>> b.authors.filter(first_name='Adam')
[]
反向查询也可以。 要查看一个作者的所有书籍,使用author.book_set ,就如这样:
>>> a = Author.objects.get(first_name='Adrian', last_name='Holovaty')
>>> a.book_set.all()
[<Book: The Django Book>, <Book: Adrian's Other Book>]
这里,就像使用 ForeignKey字段一样，属性名book_set是在数据模型(model)名后追加_set。
更改数据库模式(Database Schema)
3
在我们在第5章介绍 syncdb 这个命令时, 我们注意到 syncdb仅仅创建数据库里还没有的表，它 并不 对你数据模型的修改进行同步,也不处理数据模型的删除。 如果你新增或修改数据模型里的字段,或是删除了一个数据模型，你需要手动在数据库里进行相应的修改。 这段将解释了具体怎么做：
当处理模型修改的时候，将Django的数据库层的工作流程铭记于心是很重要的。
如果模型包含一个未曾在数据库里建立的字段，Django会报出错信息。 当你第一次用Django的数据库API请求表中不存在的字段时会导致错误（就是说，它会在运行时出错，而不是编译时）。
3
Django不关心数据库表中是否存在未在模型中定义的列。
Django不关心数据库中是否存在未被模型表示的表格。
1
改变模型的模式架构意味着需要按照顺序更改Python代码和数据库。
添加字段
1
当要向一个产品设置表(或者说是model)添加一个字段的时候，要使用的技巧是利用Django不关心表里是否包含model里所没有的列的特性。 策略就是现在数据库里加入字段，然后同步Django的模型以包含新字段。
3
然而 这里有一个鸡生蛋蛋生鸡的问题 ,由于要想了解新增列的sql语句，你需要使用Django的
manage.py sqlall命令进行查看 ,而这又需要字段已经在模型里存在了。 (注意:你并 不是非得使用与Django相同的SQL语句创建新的字段，但是这样做确实是一个好主意 ,它能让一切都保持同步。)
3
这个鸡-蛋的问题的解决方法是在开发者环境里而不是发布环境里实现这个变化。 (你正使用的是测试/开发环境，对吧?)下面是具体的实施步骤。
首先，进入开发环境(也就是说，不是在发布环境里)：
在你的模型里添加字段。
运行 manage.py sqlall [yourapp] 来测试模型新的 CREATE TABLE 语句。 注意为新字段的列定义。
开启你的数据库的交互命令界面(比如, psql 或mysql , 或者可以使用
manage.py dbshell )。 执行 ALTER TABLE 语句来添加新列。
使用Python的manage.py shell，通过导入模型和选中表单(例如，
MyModel.objects.all()[:5] )来验证新的字段是否被正确的添加 ,如果一切顺利,所有的语句都不会报错。
3
然后在你的产品服务器上再实施一遍这些步骤。
启动数据库的交互界面。
5
执行在开发环境步骤中，第三步的ALTER TABLE语句。
将新的字段加入到模型中。 如果你使用了某种版本控制工具，并且在第一步中，已经提交了你在开发环境上的修改，现在，可以在生产环境中更新你的代码了（例如，如果你使用Subversion，执行svn update。
重新启动Web server，使修改生效。
让我们实践下，比如添加一个num_pages字段到第五章中Book模型。首先，我们会把开发环境中的模型改成如下形式：
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
**num_pages = models.IntegerField(blank=True, null=True)**
def __unicode__(self):
return self.title
② python 多对多关系怎么赋值
#给多个变量赋值
data=['alex',84,[1900,3,38]]
name,age,birth=data
print(name)
print(age)
print(birth)
#
msg='hello'
a,b,c,d,e=msg
print(a,b,c,d,e)
msg='hello'
a,_,_,_,b=msg
print(a)
print(b)
#只给第一个和最后一个变量赋值
a,*_,b=msg
print(a,b)
③ python原生SQL多对多
Python由荷兰数学和计算机科学研究学会的Guido van Rossum于1990 年代初设计，作为一门叫做ABC语言的替代品。 Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言， 随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。
Python解释器易于扩展，可以使用C或C++(或者其他可以通过C调用的语言)扩展新的功能和数据类型。 Python 也可用于可定制化软件中的扩展程序语言。Python丰富的标准库，提供了适用于各个主要系统平台的源码或机器码。
2021年10月，语言流行指数的编译器Tiobe将Python加冕为最受欢迎的编程语言，20年来首次将其置于Java、C和JavaScript之上。
④ python 多对多匹配
ip.txt 跟 data.txt 的每一行都是单独一个ip的话, 整个过程应该是很容易的, 而且不用正则那么复杂啊, 只有10k跟3m行数据. 不知道你的慢是有多慢, 我自己本机上跑, 大概是0.4s内完成
ps, 你可以重写一下save函数用来保存你的数据, 我这就是简单的打印到标准输出
#!/usr/bin/envpython
#-*-encoding:utf-8-*-
defsave(line):
print(line.rstrip())
deffun():
s=set()
[s.add(e)foreinopen('ip.txt')]
[save(e)foreinopen('data.txt')ifeins]
if__name__=='__main__':
fun()
⑤ 如何理解python的多线程编程
线程是程序员必须掌握的知识，多线程对于代码的并发执行、提升代码效率和运行都至关重要。今天就分享一个黑马程序员Python多线程编程的教程，从0开始学习python多任务编程，想了解python高并发实现，从基础到实践，通过知识点 + 案例教学法帮助你想你想迅速掌握python多任务。
课程内容：
1.掌握多任务实现的并行和并发
2.掌握多进程实现多任务
3.掌握多线程实现多任务
4.掌握合理搭配多进程和线程
适用人群：
1、对python多任务编程感兴趣的在校生及应届毕业生。
2、对目前职业有进一步提升要求，希望从事python人工智能行业高薪工作的在职人员。
3、对python人工智能行业感兴趣的相关人员。
基础课程主讲内容包括：
1.python多任务编程
基础班课程大纲：
00-课程介绍
01-多任务介绍
02-进程介绍
03-使用多进程来完成多任务
04-多进程执行带有参数的任务
05-获取进程的编号
06-进程注意点
07-案例-多进程实现传智视频文件夹多任务拷贝器
08-线程介绍
09-使用多线程执行多任务
10-线程执行带有参数的任务
11-主线程和子线程的结束顺序
12-线程之间的执行顺序是无序
13-线程和进程的对比
14-案例-多线程实现传智视频文件夹多任务拷贝器
15-课程总结
⑥ python 多线程
python支持多线程效果还不错，很多方面都用到了python 多线程的知识，我前段时间用python 多线程写了个处理生产者和消费者的问题，把代码贴出来给你看下：
#encoding=utf-8
import threading
import random
import time
from Queue import Queue
class Procer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),'adding',i,'to queue'
self.sharedata.put(i)
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'
# Consumer thread
class Consumer(threading.Thread):
def __init__(self, threadname, queue):
threading.Thread.__init__(self, name = threadname)
self.sharedata = queue
def run(self):
for i in range(20):
print self.getName(),'got a value:',self.sharedata.get()
time.sleep(random.randrange(10)/10.0)
print self.getName(),'Finished'
# Main thread
def main():
queue = Queue()
procer = Procer('Procer', queue)
consumer = Consumer('Consumer', queue)
print 'Starting threads ...'
procer.start()
consumer.start()
procer.join()
consumer.join()
print 'All threads have terminated.'
if __name__ == '__main__':
main()
如果你想要了解更多的python 多线程知识可以点下面的参考资料的地址，希望对有帮助！
⑦ python 多进程
基于官方文档：
https://docs.python.org/zh-cn/3/library/multiprocessing.html
日乐购，刚才看到的一个博客，写的都不太对，还是基于官方的比较稳妥
我就是喜欢抄官方的，哈哈
通常我们使用Process实例化一个进程，并调用 他的 start() 方法启动它。
这种方法和 Thread 是一样的。
上图中，我写了 p.join() 所以主进程是 等待 子进程执行完后，才执行 print("运行结束")
否则就是反过来了（这个不一定，看你的语句了，顺序其实是随机的）例如：
主进加个 sleep
所以不加join() ,其实子进程和主进程是各干各的，谁也不等谁。都执行完后，文件运行就结束了
上面我们用了 os.getpid() 和 os.getppid() 获取 当前进程，和父进程的id
下面就讲一下，这两个函数的用法：
os.getpid()
返回当前进程的id
os.getppid()
返回父进程的id。 父进程退出后，unix 返回初始化进程（1）中的一个
windows返回相同的id (可能被其他进程使用了)
这也就解释了，为啥我上面 的程序运行多次， 第一次打印的parentid 都是 14212 了。
而子进程的父级 process id 是调用他的那个进程的 id ： 1940
视频笔记：
多进程：使用大致方法：
参考： 进程通信（pipe和queue）
pool.map （函数可以有return 也可以共享内存或queue） 结果直接是个列表
poll.apply_async() （同map,只不过是一个进程，返回结果用 xx.get() 获得）
报错：
参考 ： https://blog.csdn.net/xiemanR/article/details/71700531
把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。
结果：
这个肯定有解释的
测试多进程计算效果：
进程池运行：
结果：
普通计算：
我们同样传入 1 2 10 三个参数测试：
其实对比下来开始快了一半的；
我们把循环里的数字去掉一个 0；
单进程：
多进程：
两次测试 单进程/进程池 分别为 0.669 和 0.772 几乎成正比的。
问题 二：
视图：
post 视图里面
Music 类：
直接报错：
写在 类里面也 在函数里用 self.pool 调用也不行，也是相同的错误。
最后 把 pool = Pool 直接写在 search 函数里面，奇迹出现了：
前台也能显示搜索的音乐结果了
总结一点，进程这个东西，最好 写在 直接运行的函数里面，而不是 一个函数跳来跳去。因为最后可能 是在子进程的子进程运行的，这是不许的，会报错。
还有一点，多进程运行的函数对象，不能是 lambda 函数。也许lambda 虚拟，在内存？？
使用 pool.map 子进程 函数报错，导致整个 pool 挂了:
参考： https://blog.csdn.net/hedongho/article/details/79139606
主要你要，对函数内部捕获错误，而不能让异常抛出就可以了。
关于map 传多个函数参数
我一开始，就是正常思维，多个参数，搞个元祖，让参数一一对应不就行了：
报错：
参考：
https://blog.csdn.net/qq_15969343/article/details/84672527
普通的 process 当让可以穿多个参数，map 却不知道咋传的。
apply_async 和map 一样，不知道咋传的。
最简单的方法：
使用 starmap 而不是 map
结果：
子进程结束
1.8399453163146973
成功拿到结果了
关于map 和 starmap 不同的地方看源码：
关于apply_async() ,我没找到多参数的方法，大不了用 一个迭代的 starmap 实现。哈哈
关于 上面源码里面有 itertools.starmap
itertools 用法参考：
https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions
有个问题，多进程最好不要使用全部的 cpu , 因为这样可能影响其他任务，所以 在进程池 添加 process 参数 指定，cpu 个数：
上面就是预留了 一个cpu 干其他事的
后面直接使用 Queue 遇到这个问题：
解决：
Manager().Queue() 代替 Queue()
因为 queue.get() 是堵塞型的，所以可以提前判断是不是 空的，以免堵塞进程。比如下面这样：
使用 queue.empty() 空为True
⑧ python多线程对多核的利用
GIL 与 Python 线程的纠葛
GIL 是什么东西？它对我们的 python 程序会产生什么样的影响？我们先来看一个问题。运行下面这段 python 程序，CPU 占用率是多少？
# 请勿在工作中模仿，危险:)
def dead_loop():
while True:
pass
dead_loop()
答案是什么呢，占用 100％ CPU？那是单核！还得是没有超线程的古董 CPU。在我的双核 CPU 上，这个死循环只会吃掉我一个核的工作负荷，也就是只占用 50％ CPU。那如何能让它在双核机器上占用 100％ 的 CPU 呢？答案很容易想到，用两个线程就行了，线程不正是并发分享 CPU 运算资源的吗。可惜答案虽然对了，但做起来可没那么简单。下面的程序在主线程之外又起了一个死循环的线程
import threading
def dead_loop():
while True:
pass
# 新起一个死循环线程
t = threading.Thread(target=dead_loop)
t.start()
# 主线程也进入死循环
dead_loop()
t.join()
按道理它应该能做到占用两个核的 CPU 资源，可是实际运行情况却是没有什么改变，还是只占了 50％ CPU 不到。这又是为什么呢？难道 python 线程不是操作系统的原生线程？打开 system monitor 一探究竟，这个占了 50% 的 python 进程确实是有两个线程在跑。那这两个死循环的线程为何不能占满双核 CPU 资源呢？其实幕后的黑手就是 GIL。
GIL 的迷思：痛并快乐着
GIL 的全称为 Global Interpreter Lock ，意即全局解释器锁。在 Python 语言的主流实现 CPython 中，GIL 是一个货真价实的全局线程锁，在解释器解释执行任何 Python 代码时，都需要先获得这把锁才行，在遇到 I/O 操作时会释放这把锁。如果是纯计算的程序，没有 I/O 操作，解释器会每隔 100 次操作就释放这把锁，让别的线程有机会执行（这个次数可以通过sys.setcheckinterval 来调整）。所以虽然 CPython 的线程库直接封装操作系统的原生线程，但 CPython 进程做为一个整体，同一时间只会有一个获得了 GIL 的线程在跑，其它的线程都处于等待状态等着 GIL 的释放。这也就解释了我们上面的实验结果：虽然有两个死循环的线程，而且有两个物理 CPU 内核，但因为 GIL 的限制，两个线程只是做着分时切换，总的 CPU 占用率还略低于 50％。
看起来 python 很不给力啊。GIL 直接导致 CPython 不能利用物理多核的性能加速运算。那为什么会有这样的设计呢？我猜想应该还是历史遗留问题。多核 CPU 在 1990 年代还属于类科幻，Guido van Rossum 在创造 python 的时候，也想不到他的语言有一天会被用到很可能 1000＋ 个核的 CPU 上面，一个全局锁搞定多线程安全在那个时代应该是最简单经济的设计了。简单而又能满足需求，那就是合适的设计（对设计来说，应该只有合适与否，而没有好与不好）。怪只怪硬件的发展实在太快了，摩尔定律给软件业的红利这么快就要到头了。短短 20 年不到，代码工人就不能指望仅仅靠升级 CPU 就能让老软件跑的更快了。在多核时代，编程的免费午餐没有了。如果程序不能用并发挤干每个核的运算性能，那就意谓着会被淘汰。对软件如此，对语言也是一样。那 Python 的对策呢？
Python 的应对很简单，以不变应万变。在最新的 python 3 中依然有 GIL。之所以不去掉，原因嘛，不外以下几点：
欲练神功，挥刀自宫：
CPython 的 GIL 本意是用来保护所有全局的解释器和环境状态变量的。如果去掉 GIL，就需要多个更细粒度的锁对解释器的众多全局状态进行保护。或者采用 Lock-Free 算法。无论哪一种，要做到多线程安全都会比单使用 GIL 一个锁要难的多。而且改动的对象还是有 20 年历史的 CPython 代码树，更不论有这么多第三方的扩展也在依赖 GIL。对 Python 社区来说，这不异于挥刀自宫，重新来过。
就算自宫，也未必成功：
有位牛人曾经做了一个验证用的 CPython，将 GIL 去掉，加入了更多的细粒度锁。但是经过实际的测试，对单线程程序来说，这个版本有很大的性能下降，只有在利用的物理 CPU 超过一定数目后，才会比 GIL 版本的性能好。这也难怪。单线程本来就不需要什么锁。单就锁管理本身来说，锁 GIL 这个粗粒度的锁肯定比管理众多细粒度的锁要快的多。而现在绝大部分的 python 程序都是单线程的。再者，从需求来说，使用 python 绝不是因为看中它的运算性能。就算能利用多核，它的性能也不可能和 C/C++ 比肩。费了大力气把 GIL 拿掉，反而让大部分的程序都变慢了，这不是南辕北辙吗。
难道 Python 这么优秀的语言真的仅仅因为改动困难和意义不大就放弃多核时代了吗？其实，不做改动最最重要的原因还在于：不用自宫，也一样能成功！
其它神功
那除了切掉 GIL 外，果然还有方法让 Python 在多核时代活的滋润？让我们回到本文最初的那个问题：如何能让这个死循环的 Python 脚本在双核机器上占用 100％ 的 CPU？其实最简单的答案应该是：运行两个 python 死循环的程序！也就是说，用两个分别占满一个 CPU 内核的 python 进程来做到。确实，多进程也是利用多个 CPU 的好方法。只是进程间内存地址空间独立，互相协同通信要比多线程麻烦很多。有感于此，Python 在 2.6 里新引入了 multiprocessing这个多进程标准库，让多进程的 python 程序编写简化到类似多线程的程度，大大减轻了 GIL 带来的不能利用多核的尴尬。
这还只是一个方法，如果不想用多进程这样重量级的解决方案，还有个更彻底的方案，放弃 Python，改用 C/C++。当然，你也不用做的这么绝，只需要把关键部分用 C/C++ 写成 Python 扩展，其它部分还是用 Python 来写，让 Python 的归 Python，C 的归 C。一般计算密集性的程序都会用 C 代码编写并通过扩展的方式集成到 Python 脚本里（如 NumPy 模块）。在扩展里就完全可以用 C 创建原生线程，而且不用锁 GIL，充分利用 CPU 的计算资源了。不过，写 Python 扩展总是让人觉得很复杂。好在 Python 还有另一种与 C 模块进行互通的机制 : ctypes
利用 ctypes 绕过 GIL
ctypes 与 Python 扩展不同，它可以让 Python 直接调用任意的 C 动态库的导出函数。你所要做的只是用 ctypes 写些 python 代码即可。最酷的是，ctypes 会在调用 C 函数前释放 GIL。所以，我们可以通过 ctypes 和 C 动态库来让 python 充分利用物理内核的计算能力。让我们来实际验证一下，这次我们用 C 写一个死循环函数
extern"C"
{
void DeadLoop()
{
while (true);
}
}
用上面的 C 代码编译生成动态库 libdead_loop.so （Windows 上是 dead_loop.dll）
，接着就要利用 ctypes 来在 python 里 load 这个动态库，分别在主线程和新建线程里调用其中的 DeadLoop
from ctypes import *
from threading import Thread
lib = cdll.LoadLibrary("libdead_loop.so")
t = Thread(target=lib.DeadLoop)
t.start()
lib.DeadLoop()
这回再看看 system monitor，Python 解释器进程有两个线程在跑，而且双核 CPU 全被占满了，ctypes 确实很给力！需要提醒的是，GIL 是被 ctypes 在调用 C 函数前释放的。但是 Python 解释器还是会在执行任意一段 Python 代码时锁 GIL 的。如果你使用 Python 的代码做为 C 函数的 callback，那么只要 Python 的 callback 方法被执行时，GIL 还是会跳出来的。比如下面的例子：
extern"C"
{
typedef void Callback();
void Call(Callback* callback)
{
callback();
}
}
from ctypes import *
from threading import Thread
def dead_loop():
while True:
pass
lib = cdll.LoadLibrary("libcall.so")
Callback = CFUNCTYPE(None)
callback = Callback(dead_loop)
t = Thread(target=lib.Call, args=(callback,))
t.start()
lib.Call(callback)
注意这里与上个例子的不同之处，这次的死循环是发生在 Python 代码里 (DeadLoop 函数) 而 C 代码只是负责去调用这个 callback 而已。运行这个例子，你会发现 CPU 占用率还是只有 50％ 不到。GIL 又起作用了。
其实，从上面的例子，我们还能看出 ctypes 的一个应用，那就是用 Python 写自动化测试用例，通过 ctypes 直接调用 C 模块的接口来对这个模块进行黑盒测试，哪怕是有关该模块 C 接口的多线程安全方面的测试，ctypes 也一样能做到。
结语
虽然 CPython 的线程库封装了操作系统的原生线程，但却因为 GIL 的存在导致多线程不能利用多个 CPU 内核的计算能力。好在现在 Python 有了易经筋（multiprocessing）, 吸星大法（C 语言扩展机制）和独孤九剑（ctypes），足以应付多核时代的挑战，GIL 切还是不切已经不重要了，不是吗。
⑨ python特点和优点
python作为一门高级编程语言，它的诞生虽然很偶然，但是它得到程序员的喜爱却是必然之路，Python入门简单，相比于其他语言，初学者很容易入门。除此之外，Python还具有以下优点：
1. 简单：Python奉行简洁主义，易于读写，它使你能够专注于解决问题而不是去搞明白语言本身。
2. 免费：Python是开源软件。这意味着你不用花一分钱便能复制、阅读、改动它，这也是Python越来越优秀的原因——它是由一群希望看到一个更加优秀的Python的人创造并经常改进着的。
3. 兼容性：Python兼容众多平台，所以开发者不会遇到使用其他语言时常会遇到的困扰。
4. 面向对象：Python既支持面向过程，也支持面向对象编程。在面向过程编程中，程序员复用代码，在面向对象编程中，使用基于数据和函数的对象。
5. 丰富的库：Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI(图形用户界面)、Tk和其他与系统有关的操作。
6. 规范的代码：Python采用强制缩进的方式使得代码具有极佳的可读性。
7. 可扩展性和可嵌入性。如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。