Python分类求和方法

Python分类求和方法，Excel表格数据为例。
在Excel中经常会有根据列分类求和的需求，如果数据较少,可以在Excel中通过手动筛选的方法，但是数据较多那就比较麻烦啦。
这里需要用到groupby函数，pandas提供了一个灵活高效的groupby功能，它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。根据一个或多个键（可以是函数、数组或DataFrame列名等）拆分pandas对象。计算分组摘要统计，如计数、平均值、标准差，或用户自定义函数。对DataFrame的列应用各种各样的函数。应用组内转换或其他运算，如规格化、线性回归、排名或选取子集等。计算透视表或交叉表。执行分位数分析以及其他分组分析。
这里只简单举个例子，利用groupby函数在Excel表格中分类求和的简单实现。
需求分析，现有如下表格

需要按照不同月份汇总value值，这里可以用groupby函数简单实现。

import pandas as pd
df=pd.read_excel(‘F:\邮件张\wan.xlsx’)
df_sum = df.groupby(‘month’)[‘value’].sum()
df_sum.to_excel(‘F:\邮件张\汇总.xlsx’)
1
2
3
4
*终得到新建汇总表格如下

可以利用Python得到按照列分类的汇总。

符合Python风格的对象

Python的私有属性和受保护的属性：

如果有人编写了Dog类，这个类内部用到了mood实例属性，但是没有将其开放。

现在，你创建了Dog类的子类：Beagle。如果你在毫不知情的情况下又创建了名为mood的实例属性，那么在继承的方法中就会把Dog类的mood属性覆盖掉。

名称改写：

为了避免这个情况，如果以__mood的形式命名实例属性，Python会把属性存入实例的__dict__属性中，而且会在前面加上一个下划线和类名。

因此，对Dog类来说，__mood会变成_Dog__mood；对Beagle来说，会变成_Beagle__mood。这个特性就是名称改写。

约定俗成：

对于不喜欢使用名称改写的人，他们约定使用一个下划线前缀编写的“受保护”的属性。（如：_MyThing_blahblah）

类似于使用全大写字母表示一个常量。

__slots__类属性节省空间：

默认情况下，Python在各个实例中名为__dict__的字典里存储实例属性，字典会消耗大量内存。

继承自父类的__slots__属性没有效果。Python只会使用各个类当前类中定义的__slots__属性。

创建一个类属性__slots__，把它的值设为一个字符串构成的可迭代对象，其中各个元素表示各个实例属性。

class Vector:

__slots__ = (‘__x’,’__y’)
在类中定义了__slots__属性之后，实例不能再有__slots__中所列名称之外的其他属性。

如果类中定义了__slots__属性，而且想把实例作为弱引用的目标，要把’__weakref__’添加到__slots__中。

实例只能拥有__slots__属性，除非把”__dict__”加入到__slots__中后，会支持动态创建属性。

覆盖类属性：

类属性可用于为实例属性提供默认值。

如果为不存在的实例属性赋值，会新建实例属性。

如果想修改类属性的值，必须直接在类上修改，不能通过实例修改。

如果想修改所有实例的XX属性的默认值，可以通过 类.XX 修改

python定义类（class）的语法，

定义类（class）的语法

class Iplaypython:               #类的名字，首字母，有一个不可文的规定，*好是大写，这样需要在代码中识别区分每个类。
>>>     def fname(self, name):   #第二行开始是类的方法，大家看到了，和函数非常相似，但是与普通函数不同的是，它的内部有一个“self”，参数，它的作用是对于对象自身的引用。
>>>           self.name = name

玩蛇网是一个学习python比较好的网站

http://www.iplaypy.com/jinjie/

2）_init_函数（方法）

首先说一下，带有两个下划线开头的函数是声明该属性为私有,不能在类地外部被使用或直接访问。

类的实例（类的调用）、类的方法、构造函数、类的命名空间和作用域以及类的继承概念

Python类的定义

必须知道的概念
类 Class: 用来描述具体相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象是类的示例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

实例变量：定义在方法中的变量，只作用于当前实例的类。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关数据。

方法：类中定义的函数。在类内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为*个参数，self 代表的是类的实例。

构造函数：即__init()__，特殊的方法，在对象创建的时候被自动调用。

析构函数：即__del()__，特殊的方法，在对象被销毁时被自动调用。

实例化：创建一个类的实例，类的具体对象。就是将创建的类赋值给另一个变量。理解为赋值即可，a = class()，这个过程，就叫做实例化

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其 进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

构造函数—— “ __init__()”
当类被实例化时自动执行的函数 __init__()，如果没有写自定义的构造函数，则会执行默认构造函数，该默认构造函数”什么也不干”。

析构函数——“__del__”
__del__()也是可选的，如果不提供，则Python 会在后台提供默认析构函数。当使用del 删除对象时，会调用他本身的析构函数，另外当对象在某个作用域中调用完毕，在跳出其作用域的同时析构函数也会被调用一次，这样可以用来释放内存空间。

可显示调用析构函数，使用del语句——“del  + 对象名”

属于类级别的变量，在使用它的时候一定要带上类型名字 比如 MyClass.count

属于每个对象级别的变量，在调用的时候一定要带上self表明属于当前对象。self.name

类中的self到底是干啥的
首先需要知道的是self只有在类的方法中才会有，且self在定义类的方法时是必须有的，但是在调用时不必传入相应的参数。

另外，self名称不是必须的，在python中self不是关键词，你可以定义成a或b或其它名字都可以。

class Person:
def _init_(myname,name):
myname.name=name
def sayhello(myname):
print(‘My name is:’,myname.name)
p=Person(‘Bill’)
print(p)
*后，self指的是类实例对象本身(注意：不是类本身)。

class Test:
def ppr(self):
print(self)
print(self.__class__)

t = Test()
t.ppr()
执行结果：
<__main__.Test object at 0x000000000284E080>
<class ‘__main__.Test’>
在上述例子中，self指向的是t这个对象，而不是类本身。在Python解释器的内部，当我们调用t.ppr()时，实际上Python解释成Test.ppr(t)，也就是把self替换成了类的实例。

class Test:
def ppr():
print(self)

t = Test()
t.ppr()

运行结果：
Traceback (most recent call last):
File “cl.py”, line 6, in <module>
t.ppr()
TypeError: ppr() takes 0 positional arguments but 1 was given

class Test:
def ppr():
print(__class__)

Test.ppr()

运行结果：
<class ‘__main__.Test’>
类的私有变量、保护变量
私有变量：在类里面，在一个成员变量前加上“__”表示该变量是该类私有的，不能在外部通过类对象访问，只能在类的内部被使用。

保护变量：在类里面，在一个成员变量前加上“_”表示该变量是该类被保护的，这样的变量是可以在外部通过类的对象来访问的，但它的意思是“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”

注意：在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是私有变量。

继承
继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

单继承
什么是单继承：一个子类只从一个父类派生。

构造函数书写问题：

1.python中如果子类有自己的构造函数，不会自动调用父类的构造函数，如果需要用到父类的构造函数，则需要在子类的构造函数中显式的调用。

2.如果子类没有自己的构造函数，则会直接从父类继承构造函数，这在单继承（一个子类只从一个父类派生）中没有任何理解上的问题。

3.如何调用父类的构造函数

a.经典类的写法： 父类名称.__init__(self,参数1，参数2，…)

b. 新式类的写法：super(子类，self).__init__(参数1，参数2，….)

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

一、类、对象概述
在面向对象程序设计中，把数据以及对数据的操作封装在一起，组成一个整体（对象），不同对象之间通过消息机制来通信或者同步。对于相同类型的对象进行分类、抽象后，得出共同的特征而形成了类。
类的抽象具体包括两个方面：
1.数据抽象：描述某类对象共有的属性或状态。
2.过程抽象：描述某类对象共有的行为或功能操作。
在python中，使用类来定义同一种类型的对象。类是广义的数据类型，能够定义复杂数据的特性，包括：
1.静态特性（即数据抽象）：创建类时用变量形式表示对象特征的成员称为属性（数据成员）。
2.动态特性（即行为抽象，也就是对数据的操作方法）：用函数形式表示对象行为的成员称为成员方法，数据成员和成员方法统称为类的成员。
类是实现代码复用和设计复用的一个重要方法，封装、继承、多态是面向对象程序设计的三个要素。
类是生成对象的抽象模板，对象是根据类创建出来的一个个具体的实例。
二、类的定义与使用
Python使用class关键字来定义类，class关键字之后是一个空格，接下来是类的名字，如果派生自其它基类的话则需要把所有父类放到一对圆括号中并使用逗号分隔，然后是一个冒号，*后换行并定义类的内部实现。
类名的首字母一般要大写。
class Car(object): #定义一个类，派生自object类（所有类的祖先，定义类时不存在其他父类就写object）
can_move=True #定义类属性
def infor(self): #定义成员方法
print(“This is a car”)
1
2
3
4
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的*个参数名称, 按照惯例它的名称是 self（self代表类的实例，而非类；self 不是 python 关键字，我们把他换成其他也是可以正常执行的）。
三、类属性和类方法的调用
定义了类之后，就可以用来实例化对象，并通过“对象名.成员”的方式来访问其中的数据成员或成员方法。

>>>spring=Bird() #实例化对象
>>>print(Bird.have_feather) #通过类名调用属性
>>>print(Bird.have_head) #通过对象名调用属性
>>>spring.move() #通过对象名调用方法
>
1
2
3
4
5

类方法大体分为 3 类，分别是类方法、实例方法和静态方法，其中实例方法用的是*多的。我们知道，实例方法的调用方式其实有 2种，既可以采用类对象调用，也可以直接通过类名调用。
通常情况下，我们习惯使用类对象调用类中的实例方法。但如果想用类调用实例方法，不能像如下这样：

class Study:
def info(self):
print(“学 Python”)
#通过类名直接调用实例方法
Study.info()
1
2
3
4
5
运行上面代码，程序会报出如下错误：

Traceback (most recent call last):
File “D:\python3.6\demo.py”, line 5, in <module>
Study.info()
TypeError: info() missing 1 required positional argument: ‘self’
1
2
3
4
其中，*后一行报错信息提示我们，调用 info() 类方式时缺少给 self 参数传参。这意味着，和使用类对象调用实例方法不同，通过类名直接调用实例方法时，Python 并不会自动给 self 参数传值。
读者想想也应该明白，self 参数需要的是方法的实际调用者（是类对象），而这里只提供了类名，当然无法自动传值。

因此，如果想通过类名直接调用实例方法，就必须手动为 self 参数传值。例如修改上面的代码为：

class Study:
def info(self):
print(“学 Python”)
clang = Study()
#通过类名直接调用实例方法
Study.info(clang)
1
2
3
4
5
6
再次运行程序，结果为：

学 Python
1
可以看到，通过手动将 clang 这个类对象传给了 self 参数，使得程序得以正确执行。实际上，这里调用实例方法的形式完全是等价于 clang.info()。

值得一提的是，上面的报错信息只是让我们手动为 self 参数传值，但并没有规定必须传一个该类的对象，其实完全可以任意传入一个参数，例如：

class Study:
def info(self):
print(self,”学 Python”)
#通过类名直接调用实例方法
Study.info(“zhangsan”)
1
2
3
4
5
运行结果为：

zhangsan 学 Python
1
可以看到，“zhangsan” 这个字符串传给了 info() 方法的 self 参数。显然，无论是 info() 方法中使用 self 参数调用其它类方法，还是使用 self 参数定义新的实例变量，胡乱的给 self 参数传参都将会导致程序运行崩溃。

总的来说，Python 中允许使用类名直接调用实例方法，但必须手动为该方法的*个 self 参数传递参数，这种调用方法的方式被称为“非绑定方法”。
用类的实例对象访问类成员的方式称为绑定方法，而用类名调用类成员的方式称为非绑定方法。
(此处参考)

四、私有成员与公有成员
私有成员在类的外部不能直接访问，一般是在类的内部进行访问和操作，或者在类的外部通过调用对象的公有成员方法来访问，而公有成员是可以公开使用的，既可以在类的内部进行访问，也可以在外部程序中使用。
从形式上看，在定义类的成员时，如果成员名以两个下划线开头但是不以两个下划线结束则表示是私有成员，否则就不是私有成员。
Python并没有对私有成员提供严格的访问保护机制，通过一种特殊方式“对象名._类名__xxx”也可以在外部程序中访问私有成员，但这会破坏类的封装性，不建议这样做。

在Python中，以下划线开头的变量名和方法名有特殊的含义，尤其是在类的定义中。
_xxx：受保护成员；
__xxx__：系统定义的特殊成员；
__xxx：私有成员，只有类对象自己能访问，子类对象不能直接访问到这个成员，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。
1
2
3
注意：Python中不存在严格意义上的私有成员。
————————————————

Python类的定义与使用

目标：

1.类的定义

2.父类，子类定义，以及子类调用父类

3.类的组合使用

4.内置功能

1.类的定义

代码如下：

1. #!/usr/bin/env python
2. #coding:utf8
5. class Hotel(object):
6. “””docstring for Hotel”””
7. def __init__(self, room, cf=1.0, br=15):
8. self.room = room
9. self.cf = cf
10. self.br = br
12. def cacl_all(self, days=1):
13. return (self.room * self.cf + self.br) * days
15. if __name__ == ‘__main__’:
16. stdroom = Hotel(200)
17. big_room = Hotel(230, 0.9)
18. print stdroom.cacl_all()
19. print stdroom.cacl_all(2)
20. print big_room.cacl_all()
21. print big_room.cacl_all(3)

2.父类、子类以及调用父类

代码如下：

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
4. # 父类
5. class AddBook(object):
6. def __init__(self, name, phone):
7. self.name = name
8. self.phone = phone
10. def get_phone(self):
11. return self.phone
13. # 子类，继承
14. class EmplEmail(AddBook):
15. def __init__(self, nm, ph, email):
16. # AddBook.__init__(self, nm, ph) # 调用父类方法一
17. super(EmplEmail, self).__init__(nm, ph) # 调用父类方法二
18. self.email = email
20. def get_email(self):
21. return self.email
23. # 调用
24. if __name__ == “__main__”:
25. Detian = AddBook(‘handetian’, ‘18210413001’)
26. Meng = AddBook(‘shaomeng’, ‘18210413002’)
28. print Detian.get_phone()
29. print AddBook.get_phone(Meng)
31. alice = EmplEmail(‘alice’, ‘18210418888’, ‘alice@xkops.com’)
32. print alice.get_email(), alice.get_phone()

3.类的组合使用

代码如下：

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
4. ”’
5. 1.class类的组合使用
6. 2.手机、邮箱、QQ等是可以变化的（定义在一起），姓名不可变（单独定义）。
7. 3.在另一个类中引用
8. ”’
10. class Info(object):
11. def __init__(self, phone, email, qq):
12. self.phone = phone
13. self.email = email
14. self.qq = qq
16. def get_phone(self):
17. return self.phone
19. def update_phone(self, newphone):
20. self.phone = newphone
21. print “手机号更改已更改”
23. def get_email(self):
24. return self.email
27. class AddrBook(object):
28. ”’docstring for AddBook”’
29. def __init__(self, name, phone, email, qq):
30. self.name = name
31. self.info = Info(phone, email, qq)
34. if __name__ == “__main__”:
35. Detian = AddrBook(‘handetian’, ‘18210413001’, ‘detian@xkops.com’, ‘123456’)
36. print Detian.info.get_phone()
37. Detian.info.update_phone(18210413002)
38. print Detian.info.get_phone()
39. print Detian.info.get_email()

4.内置功能(函数（）加与不加的区别）

代码如下：

1. #!/usr/bin/env python
2. #coding:utf8
4. class Books(object):
5. def __init__(self, title, author):
6. self.title = title
7. self.author = author
9. def __str__(self):
10. return self.title
12. def __repr__(self):
13. return self.title
15. def __call__(self):
16. print “%s is written by %s” %(self.title, self.author)
19. if __name__ == ‘__main__’:
20. pybook = Books(‘Core Python’, ‘Wesley’)
21. print pybook
22. pybook()

1. #!/usr/bin/env python
2. #coding:utf8
4. class Number(object):
5. “””Custum object
6. add/radd -> +;
7. sub/rsub -> -;
8. mul/rmul -> *;
9. div/rdiv -> /;
10. “””
11. def __init__(self, number):
12. self.number = number
14. def __add__(self, other):
15. return self.number + other
17. def __radd__(self, other):
18. return self.number + other
20. def __sub__(self, other):
21. return self.number – other
23. def __rsub__(self, other):
24. return other – self.number
27. def __gt__(self, other):
28. if self.number > other:
29. return True
30. return False
33. if __name__ == ‘__main__’:
34. num = Number(10)
35. print num + 20
36. print 30 + num
37. print num – 5
38. print 11 – num
39. print num > 20

Python是什么

python 中文就是蟒蛇的意思。
在计算机中，它是一种编程语言。
Python（英语发音：/ˈpaɪθən/）, 是一种面向对象、解释型计算机程序设计语言，由Guido van Rossum于1989年底发明，*个公开发行版发行于1991年。Python语法简洁而清晰，具有丰富和强大的类库。它常被昵称为胶水语言，它能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的*终界面），然后对其中有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C++重写。
1，发展历程编辑
自从20世纪90年代初Python语言诞生至今，它逐渐被广泛应用于处理系统管理任务和Web编程。Python[1] 已经成为*受欢迎的程序设计语言之一。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。自从2004年以后，python的使用率是呈线性增长[2] 。
由于Python语言的简洁、易读以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学
已经采用Python教授程序设计课程。例如卡耐基梅隆大学的编程基础和麻省理工学院的计算机科学及编程导论就使用Python语言讲授。众多开源的科学
计算软件包都提供了Python的调用接口，
例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的
科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语
言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。
说起科学计算，首先会被提到的可能是MATLAB。然而除了MATLAB的一些专业性很强的工具箱还无法替代之外，MATLAB的大部分常用功能都可以在Python世界中找到相应的扩展库。和MATLAB相比，用Python做科学计算有如下优点：
● 首先，MATLAB是一款商用软件，并且价格不菲。而Python完全免费，众多开源的科学计算库都提供了Python的调用接口。用户可以在任何计算机上免费安装Python及其*大多数扩展库。
● 其次，与MATLAB相比，Python是一门更易学、更严谨的程序设计语言。它能让用户编写出更易读、易维护的代码。
● *后，MATLAB主要专注于工程和科学计算。然而即使在计算领域，也经常会遇到文件管理、界面设计、网络通信等各种需求。而Python有着丰富的扩展库，可以轻易完成各种高级任务，开发者可以用Python实现完整应用程序所需的各种功能。
2，产生
Python的创始人为Guido van Rossum。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，做为ABC 语言的一种继承。之所以选中Python（大蟒蛇的意思）作为程序的名字，是因为他是一个叫Monty Python的喜剧团体的爱好者。
ABC是由Guido参加设计的一种教学语言。就Guido本人看来，ABC
这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，Guido 认为是非开放造成的。Guido
决心在Python 中避免这一错误。同时，他还想实现在ABC 中闪现过但未曾实现的东西。
就这样，Python在Guido手中诞生了。可以说，Python是从ABC发展起来，主要受到了Modula-3（另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了Unix shell和C的习惯。
3，风格
Python在设计上坚持了清晰划一的风格，这使得Python成为一门易读、易维护，并且被大量用户所欢迎的、用途广泛的语言。
设计者开发时总的指导思想是，对于一个特定的问题，只要有一种*好的方法来解决就好了。这在由Tim
Peters写的Python格言（称为The Zen of Python）里面表述为：There should be one– and
preferably only one –obvious way to do it. 这正好和Perl语言（另一种功能类似的高级动态语言）的中心思想TMTOWTDI（There’s More Than One Way To Do It）完全相反。
Python的作者有意的设计限制性很强的语法，使得不好的编程习惯（例如if语句的下一行不向右缩进）都不能通过编译。其中很重要的一项就是Python的缩进规则。
一个和其他大多数语言（如C）的区别就是，一个模块的界限，完全是由每行的首字符在这一行的位置来决定的（而C语言
是用一对花括号{}来明确的定出模块的边界的，与字符的位置毫无关系）。这一点曾经引起过争议。因为自从C这类的语言诞生后，语言的语法含义与字符的排列
方式分离开来，曾经被认为是一种程序语言的进步。不过不可否认的是，通过强制程序员们缩进（包括if，for和函数定义等所有需要使用模块的地方），Python确实使得程序更加清晰和美观。
4，设计定位
Python的设计哲学是“优雅”、“明确”、“简单”。因此，Perl语言中“总是有多种方法来做同一件事”的理念在Python开发者中通常是难以忍受的。
Python开发者的哲学是“用一种方法，*好是只有一种方法来做一件事”。在设计Python语言时，如果面临多种选择，Python开发者一般会拒*
花俏的语法，而选择明确的没有或者很少有歧义的语法。由于这种设计观念的差异，Python源代码通常被认为比Perl具备更好的可读性，并且能够支撑大
规模的软件开发。这些准则被称为Python格言。在Python解释器内运行import this可以获得完整的列表。
Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python内。所以很多人认为Python很慢。不过，根据二八定律，大多数程序对速度要求不高。在某些对运行速度要求很高的情况，Python设计师
倾向于使用JIT技术，或者用使用C/C++语言改写这部分程序。可用的JIT技术是PyPy。
Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式程序设计工具。
虽然Python可能被粗略地分类为“脚本语言”（script language），但实际上一些大规模软件开发计划例如Zope、Mnet及BitTorrent，Google也广泛地使用它。Python的支持者较喜欢称它为一种高级动态编程语言，原因是“脚本语言”泛指仅作简单程序设计任务的语言，如shellscript、VBScript等只能处理简单任务的编程语言，并不能与Python相提并论。
Python本身被设计为可扩充的。并非所有的特性和功能都集成到语言核心。Python提供了丰富的API和
工具，以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。Python编译器本身也可以被集成到其它需要脚本语言的程序内。因此，很
多人还把Python作为一种“胶水语言”（glue
language）使用。使用Python将其他语言编写的程序进行集成和封装。在Google内部的很多项目，例如Google
Engine使用C++编写性能要求*高的部分，然后用Python或Java/Go调用相应的模块。《Python技术手册》的作者马特利（AlexMartelli）说：“这很难讲，不过，2004 年，Python 已在 Google 内部使用，Google 召募许多 Python高手，但在这之前就已决定使用Python，他们的目的是 Python where we can, C++ where we
must，在操控硬件的场合使用 C++，在快速开发时候使用 Python。”

Python并发技术

1、前言
目前大多数编程语言都直接支持并发，而且其标准库通常还提供了一些封装程度较高的功能。并发可以用多种方式来实现，这些方式*重要的区别在于如何访问”共享数据”：是通过”共享内存”等方式直接访问，还是通过”进程间通信”等方式访问。

基于线程的并发：是指同一个系统进程里有各自独立的若干个线程，它们都在并发执行任务。这些线程一般会依序访问共享内存，以此实现数据共享。程序中，通常采用某种锁定机制来确保同一时间只有一个线程能够访问数据。

基于进程的并发：是指多个进程独立地执行任务，这些进程一般通过IPC来访问数据，如果编程语言或者程序库支持，那么也可以通过共享内存来实现数据共享。
还有一种并发，它基于并发等待，而非并发执行，这种方式通常用来实现异步IO。

Python都支持上述两种方式。
Python对多线程的支持方式相当普通，但对于多进程的支持则比大多数语言或程序库更为高级，此外Python的多进程与多线程采用同一套机制，使得开发者很容易就能在两套方案中来回切换。

由于全局解释器锁(GIL)，所以Python解释器器在同一刻只能运行于一个处理器中，因此想通过多线程并发来提升程序速度，其效果可能仍然不够理想。

一般来说，计算密集型任务不适合用多线程来实现，因为者通常比非并发程序还要慢。
一种方法是改用Cython来编写代码，Cython代码实际上与Python一样，只是多加了一套写法，能够把程序编译成纯C。这种程序执行起来可以比原来快100倍，而并发很难达到这样的效果。
如果遇到使用并发的场合，而所执行的任务又是计算密集型的，*好避开GIL，改用multiprocessing模块。如何使用多线程，那么同一个进程里的线程在执行时会相互争抢GIL，但如果改用multiprocessing模块，那么每个进程都是独立的，它们都有自己的Python解释器锁，所以就不会争夺GIL了。

对于网络通信等”网络密集型”任务来说，并发可以大幅提高程序执行速度，在这种情况下，决定程序效率的注意因素是网络延迟，这与使用线程还是进程来实现并发没有多大关系。

2、计算密集型并发
使用多线程来执行计算密集型任务的效率比非并发程序的效率还要低，
这是因为python 将所有处理任务都放在了同一个核里。
使用多进程会把任务排布在多个核心上面。
计算密集型程序所使用的线程或进程数量一般与核心数相同。

(1) 用队列及多进程实现并发
(2)用Future及多进程实现并发
Python 3.2 新增了concurrent.futures模块，提供了一种优雅而高级的方式，可以用多线程或多进程实现并发。

3、IO密集型并发
(1)用队列及线程实现并发
(2) 用Future及多进程实现并发