Python如何实现面相切面

⑴ python是面向什么的高级语言

面相对象、解释型。

Python支持多种编程范型，包括函数式、指令式、反射式、结构化和面向对象编程。它拥有动态类型系统和垃圾回收功能，能够自动管理内存使用，并且其本身拥有一个巨大而广泛的标准库。它的语言结构以及面向对象的方法旨在帮助程序员为小型的和大型的项目编写清晰的、合乎逻辑的代码。

吉多·范罗苏姆于1980年代后期开始研发Python，它是作为ABC语言的后继者，也可以视之为使用叫做的M-表达式的一种传统中缀表示法的LISP方言。

吉多·范罗苏姆于1991年首次发布 Python 0.9.0。Python2.0于2000 年发布并引入了新功能。Python3.0于2008年发布，是该语言的主要修订版，并非完全向后兼容。 Python2于2020年随2.7.18版停止使用。

Python的设计哲学强调代码的可读性和简洁的语法，尤其是使用空格缩进划分代码块。相比于C或java，Python让开发者能够用更少的代码表达想法。

Python解释器本身几乎可以在所有的操作系统中运行。Python的官方解释器CPython是用C语言编写的，它是一个由社群驱动的自由软件，目前由Python软件基金会管理。

特征

Python是多范型编程语言。它完全支持结构化编程和面向对象编程，还有很多特征支持函数式编程和元编程比如元对象协议（元类和魔术方法）。

通过扩展还可以支持很多范型，包括面向切面编程、契约式设计和逻辑编程。

Python使用动态类型，在内存管理上采用引用计数和环检测相结合的垃圾收集器。它的特征还有动态名字解析（后期绑定），即在程序执行期间绑定方法和变量的名字。

Python对遵循LISP传统的函数式编程提供了有限的支持，它提供了map、filter和rece函数；列表推导式、字典、集合和生成器表达式。

⑵ 用python如何实现啊

from random import randint

class Shengfen(object):

def __init__(self, sname):

self.sname = sname

def shengfen(self):

print(self.sname)

class Dijishi(Shengfen):

def __init__(self, sname, dname):

Shengfen.__init__(self, sname)

self.dname = dname

self.money = 10000 #现有钱数

self.number = 0 #商品数量

self.jycs = 0 #交易次数

def attach_g(self): #联系供应商

self.money -= 100

self.number += 1

if self.number >= 4:

self.xiaoshou() #库存积攒到4件时，开始销售该商品

print("现有钱数：" + str(self.money))

print("现有商品数量：" + str(self.number))

def xiaoshou(self): #销售该商品

if self.jycs < 4: #交易次数小于4次，继续交易

self.money += 110

self.number -= 1

self.jycs += 1

else: #交易次数大于4次，又百分之50的几率退货

if randint(1,2) == 1: #用randint函数创建1/2概率

self.money += 110

self.number -= 1

else:

self.tuihuo()

def tuihuo(self):

self.money -= 30 #退货一件，相当于亏了30元

print("退货一件")

class Gebishi(Shengfen):

def __init__(self, sname, gname):

Shengfen.__init__(self, sname)

self.gname = gname

if __name__ == "__main__":

count = 9 #交易次数

Qinshihuang = Dijishi('Guangdong', 'Guangzhou')

Liubang = Gebishi('Guangdong', 'Foshan')

Hanxin = Gebishi('Guangdong', 'Foshan')

for i in range(count):

Qinshihuang.attach_g()

大致按照要求来写了一下，可能有些地方还有问题，如果有的话，你留言一下，我再帮你改吧

⑶ python是面向对象还是面向过程

面向过程和面对对象是一种编程思想，不能说某某语言是不是面对对象或是面向过程，而是某某语言是否支持面对对象或面向过程。回归主题，python可以支持面对对象，但也可以支持面向过程，即使不支持面向对象的语言，比如c语言，也可以用面对对象的思想写程序。你可以理解面对对象为“模块化”，恰巧python可以做到这一点，自己编写的函数文件可以用import引用模块，即使不使用class定义类，也可以实现面对对象的思想。

⑷ 如何设计插件式结构的程序，兼谈Python语言

为了扩充软件的功能，通常我们会把软件设计成插件式结构。Python这样的动态语言天生就支持插件式编程。与C++相比，Python已经定义好模块的接口，想要载入一个插件，一个__import__()就能很轻松地搞定。不需要特定的底层知识。而且与C++等静态语言相比，Python的插件式结构更显灵活。因为插件载入后，可以利用Python语言的动态性，充分地修改核心的逻辑。
简单地说一个__import__()可能不大清楚。现在就来看一个最简单的插件式结构程序。它会扫描plugins文件夹下的所有.py文件。然后把它们载入。
#-*- encoding: utf-8 -*-#main1.pyimport osclass Platform:
def __init__(self):
self.loadPlugins()

def sayHello(self, from_):
print "hello from %s." % from_

def loadPlugins(self):
for filename in os.listdir("plugins"):
if not filename.endswith(".py") or filename.startswith("_"):
continue
self.runPlugin(filename)

def runPlugin(self, filename):
pluginName=os.path.splitext(filename)[0]
plugin=__import__("plugins."+pluginName, fromlist=[pluginName])
#Errors may be occured. Handle it yourself.
plugin.run(self)if __name__=="__main__":
platform=Platform()

然后在plugins子目录里面放入两个文件：
#plugins1.pydef run(platform):
platform.sayHello("plugin1")#plugins2.pydef run(platform):
platform.sayHello("plugin2")

再创建一个空的__init__.py在plugins文件夹里面。从package里面导入模块的时候，Python要求一个__init__.py。
运行main1.py，看一下运行的结果。首先是打印一下文件夹结构方便大家理解：
h:\projects\workon\testplugins>tree /f /a
卷 Data 的文件夹 PATH 列表
卷序列号为 ****-****
H:.
| main1.py
|
\---plugins
plugin1.py
plugin2.py
__init__.py

h:\projects\workon\testplugins>main1.py
hello from plugin1.
hello from plugin2.

一般地，载入插件前要首先扫描插件，然后依次载入并运行插件。我们上面的示例程序main1.py也是如此，分为两个函数。第一个loadPlugins()扫描插件。它把plugins目录下面所有.py的文件除了__init__.py都当成插件。runPlugin()载入并运行插件。其中两个关键：使用__import__()函数把插件当成模块导入，它要求所有的插件都定义一个run()函数。各种语言实现的插件式结构其实也基本上分为这两个步骤。所不同的是，Python语言实现起来更加的简洁。
或许听起来还有点玄奥。详细地说一下__import__()。它和常见的import语句很相似，只不过换成函数形式并且返回模块以供调用。import mole相当于__import__("mole")，from mole import func相当于__import__("mole", fromlist=["func"])，不过与想象有点不同，import package.mole相当于__import__("package.mole", fromlist=["mole"])。
如何调用插件一般有个约定。像我们这里就约定每个插件都实现一个run()。有时候还可以约定实现一个类，并且要求这个类实现某个管理接口，以方便核心随时启动、停止插件。要求所有的插件都有这几个接口方法：
#interfaces.pyclass Plugin:
def setPlatform(self, platform):
self.platform=platform

def start(self):
pass

def stop(self):
pass

想要运行这个插件，我们的runPlugin()要改一改，另外增加一个shutdown()来停止插件:
class Platform:
def __init__(self):
self.plugins=[]
self.loadPlugins()

def sayHello(self, from_):
print "hello from %s." % from_

def loadPlugins(self):
for filename in os.listdir("plugins"):
if not filename.endswith(".py") or filename.startswith("_"):
continue
self.runPlugin(filename)

def runPlugin(self, filename):
pluginName=os.path.splitext(filename)[0]
plugin=__import__("plugins."+pluginName, fromlist=[pluginName])
clazz=plugin.getPluginClass()
o=clazz()
o.setPlatform(self)
o.start()
self.plugins.append(o)

def shutdown(self):
for o in self.plugins:
o.stop()
o.setPlatform(None)
self.plugins=[]if __name__=="__main__":
platform=Platform()
platform.shutdown()

插件改成这样：
#plugins1.pyclass Plugin1:
def setPlatform(self, platform):
self.platform=platform

def start(self):
self.platform.sayHello("plugin1")

def stop(self):
self.platform.sayGoodbye("plugin1")def getPluginClass():
return Plugin1#plugins2.pydef sayGoodbye(self, from_):
print "goodbye from %s." % from_class Plugin2:
def setPlatform(self, platform):
self.platform=platform
if platform is not None:
platform.__class__.sayGoodbye=sayGoodbye

def start(self):
self.platform.sayHello("plugin2")

def stop(self):
self.platform.sayGoodbye("plugin2")def getPluginClass():
return Plugin2

运行结果：
h:\projects\workon\testplugins>main.py
hello from plugin1.
hello from plugin2.
goodbye from plugin1.
goodbye from plugin2.

详细观察的朋友们可能会发现，上面的main.py,plugin1.py, plugin2.py干了好几件令人惊奇的事。
首先，plugin1.py和plugin2.py里面的插件类并没有继承自interfaces.Plugin，而platform仍然可以直接调用它们的start()和stop()方法。这件事在Java、C++里面可能是件麻烦的事情，但是在Python里面却是件稀疏平常的事，仿佛吃饭喝水一般正常。事实上，这正是Python鼓励的约定编程。Python的文件接口协议就只规定了read(), write(), close()少数几个方法。多数以文件作为参数的函数都可以传入自定义的文件对象，只要实现其中一两个方法就行了，而不必实现一个什么FileInterface。如果那样的话，需要实现的函数就多了，可能要有十几个。
再仔细看下来，getPluginClass()可以把类型当成值返回。其实不止是类型，Python的函数、模块都可以被当成普通的对象使用。从类型生成一个实例也很简单，直接调用clazz()就创建一个对象。不仅如此，Python还能够修改类型。上面的例子我们就演示了如何给Platform增加一个方法。在两个插件的stop()里面我们都调用了sayGoodbye()，但是仔细观察Platform的定义，里面并没有定义。原理就在这里：
#plugins2.pydef sayGoodbye(self, from_):
print "goodbye from %s." % from_class Plugin2:
def setPlatform(self, platform):
self.platform=platform
if platform is not None:
platform.__class__.sayGoodbye=sayGoodbye

这里首先通过platform.__class__得到Platform类型，然后Platform.sayGoodbye=sayGoodbye新增了一个方法。使用这种方法，我们可以让插件任意修改核心的逻辑。这正在文首所说的Python实现插件式结构的灵活性，是静态语言如C++、Java等无法比拟的。当然，这只是演示，我不大建议使用这种方式，它改变了核心的API，可能会给其它程序员造成困惑。但是可以采用这种方式替换原来的方法，还可以利用“面向切面编程”，增强系统的功能。
接下来我们还要再改进一下载入插件的方法，或者说插件的布署方法。前面我们实现的插件体系主要的缺点是每个插件只能有一个源代码。如果想附带一些图片、声音数据，又怕它们会和其它的插件冲突。即使不冲突，下载时分成单独的文件也不方便。最好是把一个插件压缩成一个文件供下载安装。
Firefox是一个支持插件的着名软件。它的插件以.xpi作为扩展名，实际上是一个.zip文件，里面包含了javascript代码、数据文件等很多内容。它会把插件包下载复制并解压到%APPDATA%\Mozilla\Firefox\Profiles\XXXX.default\extensions里面，然后调用其中的install.js安装。与此类似，实用的Python程序也不大可能只有一个源代码，也要像Firefox那样支持.zip包格式。
实现一个类似于Firefox那样的插件布署体系并不会很难，因为Python支持读写.zip文件，只要写几行代码来做压缩与解压缩就行了。首先要看一下zipfile这个模块。用它解压缩的代码如下：
import zipfile, osdef installPlugin(filename):
with zipfile.ZipFile(filename) as pluginzip:
subdir=os.path.splitext(filename)[0]
topath=os.path.join("plugins", subdir)
pluginzip.extractall(topath)

ZipFile.extractall()是Python 2.6后新增的函数。它直接解压所有压缩包内的文件。不过这个函数只能用于受信任的压缩包。如果压缩包内包含了以/或者盘符开始的绝对路径，很有可能会损坏系统。推荐看一下zipfile模块的说明文档，事先过滤非法的路径名。
这里只有解压缩的一小段代码，安装过程的界面交互相关的代码很多，不可能在这里举例说明。我觉得UI是非常考验软件设计师的部分。常见的软件会要求用户到网站上查找并下载插件。而Firefox和KDE提供了一个“组件(部件)管理界面”，用户可以直接在界面内查找插件，查看它的描述，然后直接点击安装。安装后，我们的程序遍历插件目录，载入所有的插件。一般地，软件还需要向用户提供插件的启用、禁用、依赖等功能，甚至可以让用户直接在软件界面上给插件评分，这里就不再详述了。
有个小技巧，安装到plugins/subdir下的插件可以通过__file__得到它自己的绝对路径。如果这个插件带有图片、声音等数据的时候，可以利用这个功能载入它们。比如上面的plugin1.py这个插件，如果它想在启动的时候播放同目录的message.wav，可以这样子：
#plugins1.pyimport osdef alert():
soundFile=os.path.join(os.path.dirname(__file__), "message.wav")
try:
import winsound
winsound.PlaySound(soundFile, winsound.SND_FILENAME)
except (ImportError, RuntimeError):
passclass Plugin1:
def setPlatform(self, platform):
self.platform=platform

def start(self):
self.platform.sayHello("plugin1")
alert()

def stop(self):
self.platform.sayGoodbye("plugin1")def getPluginClass():
return Plugin1

接下来我们再介绍一种Python/Java语言常用的插件管理方式。它不需要事先有一个插件解压过程，因为Python支持从.zp文件导入模块，很类似于Java直接从.jar文件载入代码。所谓安装，只要简单地把插件复制到特定的目录即可，Python代码自动扫描并从.zip文件内载入代码。下面是一个最简单的例子，它和上面的几个例子一样，包含一个main.py，这是主程序，一个plugins子目录，用于存放插件。我们这里只有一个插件，名为plugin1.zip。plugin1.zip有以下两个文件，其中description.txt保存了插件内的入口函数和插件的名字等信息，而plugin1.py是插件的主要代码:
description.txt
plugin1.py

其中description.txt的内容是:
[general]name=plugin1description=Just a test code=plugin1.Plugin1

plugin1.py与前面的例子类似，为了省事，我们去掉了stop()方法，它的内容是:
class Plugin1:
def setPlatform(self, platform):
self.platform=platform

def start(self):
self.platform.sayHello("plugin1")

重写的main.py的内容是:
# -*- coding: utf-8 -*-import os, zipfile, sys, ConfigParserclass Platform:
def __init__(self):
self.loadPlugins()

def sayHello(self, from_):
print "hello from %s." % from_

def loadPlugins(self):
for filename in os.listdir("plugins"):
if not filename.endswith(".zip"):
continue
self.runPlugin(filename)

def runPlugin(self, filename):
pluginPath=os.path.join("plugins", filename)
pluginInfo, plugin = self.getPlugin(pluginPath)
print "loading plugin: %s, description: %s" % \ (pluginInfo["name"], pluginInfo["description"])
plugin.setPlatform(self)
plugin.start()

def getPlugin(self, pluginPath):
pluginzip=zipfile.ZipFile(pluginPath, "r")
description_txt=pluginzip.open("description.txt")
parser=ConfigParser.ConfigParser()
parser.readfp(description_txt)
pluginInfo={}
pluginInfo["name"]=parser.get("general", "name")
pluginInfo["description"]=parser.get("general", "description")
pluginInfo["code"]=parser.get("general", "code")

sys.path.append(pluginPath)
moleName, pluginClassName=pluginInfo["code"].rsplit(".", 1)
mole=__import__(moleName, fromlist=[pluginClassName, ])
pluginClass=getattr(mole, pluginClassName)
plugin=pluginClass()
return pluginInfo, pluginif __name__=="__main__":
platform=Platform()

与前一个例子的主要不同之处是getPlugin()。它首先从.zip文件内读取描述信息，然后把这个.zip文件添加到sys.path里面。最后与前面类似地导入模块并执行。
解压还是不解压，两种方案各有优劣。一般地，把.zip文件解压到独立的文件夹内需要一个解压缩过程，或者是人工解压，或者是由软件解压。解压后的运行效率会高一些。而直接使用.zip包的话，只需要让用户把插件复制到特定的位置即可，但是每次运行的时候都需要在内存里面解压缩，效率降低。另外，从.zip文件读取数据总是比较麻烦。推荐不包含没有数据文件的时候使用。
阅读全文

⑸ python装饰器有什么用

先来个形象比方

内裤可以用来遮羞，但是到了冬天它没法为我们防风御寒，聪明的人们发明了长裤，有了长裤后宝宝再也不冷了，装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。

再回到我们的主题

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

先来看一个简单例子：

def foo():
print('i am foo')

现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：

def foo():
print('i am foo')
logging.info("foo is running")

bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码

def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()def bar():
print('i am bar')use_logging(bar)

逻辑上不难理解，
但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。

简单装饰器
def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapperdef bar():
print('i am bar')bar = use_logging(bar)bar()

函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时
，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作

def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper@use_loggingdef foo():
print("i am foo")@use_loggingdef bar():
print("i am bar")bar()

如上所示，这样我们就可以省去bar =
use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。

def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

return decorator@use_logging(level="warn")def foo(name='foo'):
print("i am %s" % name)foo()

上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我
们使用@use_logging(level="warn")调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。

类装饰器

再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):
def __init__(self, func):
self._func = func

def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')

@Foo
def bar():
print ('bar')

bar()

functools.wraps

使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：

装饰器

def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

函数

@loggeddef f(x):
"""does some math"""
return x + x * x

该函数完成等价于：

def f(x):
"""does some math"""
return x + x * xf = logged(f)

不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。

print f.__name__ # prints 'with_logging'print f.__doc__ # prints None

这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。

from functools import wrapsdef logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging@loggeddef f(x):
"""does some math"""
return x + x * xprint f.__name__ # prints 'f'print f.__doc__ # prints 'does some math'

内置装饰器

@staticmathod、@classmethod、@property

装饰器的顺序
@a@b@cdef f ():

等效于

f = a(b(c(f)))

⑹ Python如何工作

Python的特色
简单
Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样，尽管这个英语的要求非常严格！Python的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。

易学
就如同你即将看到的一样，Python极其容易上手。前面已经提到了，Python有极其简单的语法。

免费、开源
Python是FLOSS（自由/开放源码软件）之一。简单地说，你可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。这是为什么Python如此优秀的原因之一——它是由一群希望看到一个更加优秀的Python的人创造并经常改进着的。

高层语言
当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

可移植性
由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有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！

解释性
这一点需要一些解释。

一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。当你运行你的程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。

而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码 运行 程序。在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用Python更加简单。由于你只需要把你的Python程序拷贝到另外一台计算机上，它就可以工作了，这也使得你的Python程序更加易于移植。

面向对象
Python即支持面向过程的编程也支持面向对象的编程。在 面向过程 的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在 面向对象 的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。

可扩展性
如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。

可嵌入性
你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。

丰富的库
Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。

除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。

⑺ 如何深入理解Python中的面向对象的思维

ython使用类(class)和对象(object)，进行面向对象（object-oriented programming，简称OOP）的编程。
面向对象的最主要目的是提高程序的重复使用性。我们这么早切入面向对象编程的原因是，Python的整个概念是基于对象的。了解OOP是进一步学习Python的关键。
下面是对面向对象的一种理解，基于分类。
相近对象，归为类
在人类认知中，会根据属性相近把东西归类，并且给类别命名。比如说，鸟类的共同属性是有羽毛，通过产卵生育后代。任何一只特别的鸟都在鸟类的原型基础上的。

对这方面感兴趣，想要学习python或者想要了解python可以加群：623715703
面向对象就是模拟了以上人类认知过程。在Python语言，为了听起来酷，我们把上面说的“东西”称为对象（object）。
面向对象的基本思想是封装，继承，多态。
首先是继承：
定义一个类：
复制代码 代码如下:
class Bird(object):
have_feather = True
way_of_reproction = 'egg'
调用这个类：
summer = Bird()
print summer.way_of_reproction
与Java不同是，Python是不需要new来实例化类的。
同样，Python的类下面是可以定方法的：
def say(self, word='hi hi'):
print 'i say :' + word
注意一点，所有类的函数，必须至少带有一个参数，这个参数必须是self。
类以外的函数没有这一个限制。
chk = Chicken()
print chk.have_feather
print chk.sat('hello')
__init__()方法
__init__()是一个特殊方法(special method)。Python里会有一些特殊方法，Python会以特别的方式处理它们。特殊方法的名字的特点是前后都有两个下划线。

__init__()方法的特殊在于，如果你在类中定义了这个方法，一旦你根据这个类建立对象，Python就会自动调用这个方法（这个过程也叫初始化）。
如：
class happyBird(Bird):
def __init__(self,more_words):
print 'We are happy birds.',more_words
hb = happyBird('Happy,Happy!')
父类方法的重载：
class Hello(object):
name = 'hello'
def __init__(self):
self.name='my name is hello'
#类中的参数必须带有self参数
def sayhi(self):
print 'hi you'
class World(Hello):
#这里访问的是父类初始化的变量名
print 'before:',Hello.name
super(World,self).__init__()
#由于调用了父类的初始化构造函数，继承了父类的变量的改变
print 'after:',self.name
#近似于方法重载
def sayhi(self,word='baby'):
#调用父类sayhi方法
super(World,self).sayhi()
print 'hi '+word
def sayWorld(self):
print 'hi,hello world'
if __name__ == '__main__':
c = World()
c.sayhi()
c.sayWorld()

另外，python是允许多继承的，但是这个是个非常危险的操作，建议不要随便使用。
关于Python的多态，就像JavaScript一样，直接访问对象的属性，不需要使用接口，没有类型转换。
对于类型的判断，有抓们的type()函数，和isinstance()函数判断是否某个函数的子类。
isinstance(object, classinfo)
判断实例是否是这个类或者object是变量
classinfo 是类型(tuple,dict,int,float)
判断变量是否是这个类型
class objA:
pass
A = objA()
B = 'a','v'
C = 'a string'
print isinstance(A, objA)
print isinstance(B, tuple)
print isinstance(C, basestring)
输出结果：
True

将东西根据属性归类 ( 将object归为class )
方法是一种属性，表示动作
用继承来说明父类-子类关系。子类自动具有父类的所有属性。
self代表了根据类定义而创建的对象。
建立对一个对象： 对象名 = 类名()
引用对象的属性： object.attribute
希望小伙伴们早日成为大牛！

⑻ C 语言和 Python，该从哪个入门编程

先说结论，建议C
首先你要看看自己是要干什么，学习X语言只有两个目的：
1，成为一名软狗。
2，成为一名伪软狗。
如果你要成为一名软狗，请学习C。因为C是一贫如洗的语言，C能给你最好的逻辑锻炼而不是给你个库你看看有什么功能。
如果你要成为一名伪软狗，请学习C。
为啥呢，笑，因为你连C都不会怎么装x啊。当然这不是重点。(逃
由于C的先天的单纯和面向过程的特性，以及略现死板的编码要求，都让人能够快速掌握编程思想。但是C要学到什么程度就见仁见智了。比如我要成为一个嵌入式程序员，我就必须对C的各种小库了如指掌，各种函数什么功能，指针怎么指来指去。还需要明确内存操作等相关问题。最后类似于用C来实现某些位运算啊I/O调用啊小破标志位动来动去啊。
但是我要成为一个工业生产程序员我就了解C的基本思想就行了，无需了解C中相对不容易调用的库，也不用太考虑指针和位运算。因为我的思路是要向面向对象甚至面向切面拓展的。
至于python，我也是很喜欢啊，最近刚刚入门。感觉好简洁啊，好欢乐啊，很多C#搞半天的玩意一会儿就写完了啊，站在了巨人肩膀上真是爽啊，前人栽树好乘凉啊！！
不过这都是我使用C=》C++（也就大学学了点）=》C#后的感觉。
要是我上来学的是python，我的感觉估计就是哎我去怎么怎么坑爹这语法，哎我去这个实现怎么这么费劲，哎我去缩进和逻辑怎么没关系。。。
先入为主的编程思想，很影响后续语言的学习的。
不过Python也很不错，可以相当快速度入门，急速做出东西。学习曲线比较平缓而且最重要的是比较有成就感。
总结一下吧：
如果你想要作为一个程序员生活下去，请以C入门，没错的。
如果你想要在小白面前一展谈资，请以C入门，妥妥的。
如果你想要迅速做出需要的东西，请怒学Python，学成了记得给我培训下。
如果你想要后续撬开面向对象或面向切面大门，请学C。
对Java等面向对象语言没兴趣就是想写代码，Python。
以上。

⑼ 如何理解 Python

简单例子：
def foo():
print('i am foo')

现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：
def foo():
print('i am foo')
logging.info("foo is running")

bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()

def bar():
print('i am bar')

use_logging(bar)

逻辑上不难理解， 但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。

简单装饰器

def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper

def bar():
print('i am bar')

bar = use_logging(bar)
bar()

函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作

def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

@use_logging
def foo():
print("i am foo")

@use_logging
def bar():
print("i am bar")

bar()

如上所示，这样我们就可以省去bar = use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

带参数的装饰器
装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

return decorator

@use_logging(level="warn")
def foo(name='foo'):
print("i am %s" % name)

foo()

上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。

类装饰器
再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):
def __init__(self, func):
self._func = func

def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')

@Foo
def bar():
print ('bar')

bar()

functools.wraps
使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：
装饰器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

函数
@logged
def f(x):
"""does some math"""
return x + x * x

该函数完成等价于：

def f(x):
"""does some math"""
return x + x * x
f = logged(f)

不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。
print f.__name__ # prints 'with_logging'
print f.__doc__ # prints None

这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。
from functools import wraps
def logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

@logged
def f(x):
"""does some math"""
return x + x * x

print f.__name__ # prints 'f'
print f.__doc__ # prints 'does some math'

内置装饰器
@staticmathod、@classmethod、@property
装饰器的顺序

@a
@b
@c
def f ():

等效于

f = a(b(c(f)))

⑽ 如何理解Python装饰器

理解Python中的装饰器
@makebold
@makeitalic
def say():
return "Hello"

打印出如下的输出：
<b><i>Hello<i></b>

你会怎么做？最后给出的答案是：

def makebold(fn):
def wrapped():
return "<b>" + fn() + "</b>"
return wrapped

def makeitalic(fn):
def wrapped():
return "<i>" + fn() + "</i>"
return wrapped

@makebold
@makeitalic
def hello():
return "hello world"

print hello() ## 返回 <b><i>hello world</i></b>

现在我们来看看如何从一些最基础的方式来理解Python的装饰器。英文讨论参考Here。
装饰器是一个很着名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
1.1. 需求是怎么来的？
装饰器的定义很是抽象，我们来看一个小例子。

def foo():
print 'in foo()'
foo()

这是一个很无聊的函数没错。但是突然有一个更无聊的人，我们称呼他为B君，说我想看看执行这个函数用了多长时间，好吧，那么我们可以这样做：

import time
def foo():
start = time.clock()
print 'in foo()'
end = time.clock()
print 'used:', end - start

foo()

很好，功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了，他对另一个叫foo2的函数产生了更浓厚的兴趣。
怎么办呢？如果把以上新增加的代码复制到foo2里，这就犯了大忌了~复制什么的难道不是最讨厌了么！而且，如果B君继续看了其他的函数呢？
1.2. 以不变应万变，是变也
还记得吗，函数在Python中是一等公民，那么我们可以考虑重新定义一个函数timeit，将foo的引用传递给他，然后在timeit中调用foo并进行计时，这样，我们就达到了不改动foo定义的目的，而且，不论B君看了多少个函数，我们都不用去修改函数定义了！

import time

def foo():
print 'in foo()'

def timeit(func):
start = time.clock()
func()
end =time.clock()
print 'used:', end - start

timeit(foo)

看起来逻辑上并没有问题，一切都很美好并且运作正常！……等等，我们似乎修改了调用部分的代码。原本我们是这样调用的：foo()，修改以后变成了：timeit(foo)。这样的话，如果foo在N处都被调用了，你就不得不去修改这N处的代码。或者更极端的，考虑其中某处调用的代码无法修改这个情况，比如：这个函数是你交给别人使用的。
1.3. 最大限度地少改动！
既然如此，我们就来想想办法不修改调用的代码；如果不修改调用代码，也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo，但是timeit似乎带有一个参数……想办法把参数统一吧！如果timeit(foo)不是直接产生调用效果，而是返回一个与foo参数列表一致的函数的话……就很好办了，将timeit(foo)的返回值赋值给foo，然后，调用foo()的代码完全不用修改！

#-*- coding: UTF-8 -*-
import time

def foo():
print 'in foo()'

# 定义一个计时器，传入一个，并返回另一个附加了计时功能的方法
def timeit(func):

# 定义一个内嵌的包装函数，给传入的函数加上计时功能的包装
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start

# 将包装后的函数返回
return wrapper

foo = timeit(foo)
foo()

这样，一个简易的计时器就做好了！我们只需要在定义foo以后调用foo之前，加上foo = timeit(foo)，就可以达到计时的目的，这也就是装饰器的概念，看起来像是foo被timeit装饰了。在在这个例子中，函数进入和退出时需要计时，这被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言，像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里，能减少大量重复代码。面向切面编程还有相当多的术语，这里就不多做介绍，感兴趣的话可以去找找相关的资料。
这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了 ：）
上面这段代码看起来似乎已经不能再精简了，Python于是提供了一个语法糖来降低字符输入量。

import time

def timeit(func):
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start
return wrapper

@timeit
def foo():
print 'in foo()'

foo()

重点关注第11行的@timeit，在定义上加上这一行与另外写foo = timeit(foo)完全等价，千万不要以为@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感觉。
-------------------
要理解python的装饰器，我们首先必须明白在Python中函数也是被视为对象。这一点很重要。先看一个例子：

def shout(word="yes") :
return word.capitalize()+" !"

print shout()
# 输出 : 'Yes !'

# 作为一个对象，你可以把函数赋给任何其他对象变量

scream = shout

# 注意我们没有使用圆括号，因为我们不是在调用函数
# 我们把函数shout赋给scream，也就是说你可以通过scream调用shout

print scream()
# 输出 : 'Yes !'

# 还有，你可以删除旧的名字shout，但是你仍然可以通过scream来访问该函数

del shout
try :
print shout()
except NameError, e :
print e
#输出 : "name 'shout' is not defined"

print scream()
# 输出 : 'Yes !'

我们暂且把这个话题放旁边，我们先看看python另外一个很有意思的属性：可以在函数中定义函数：

def talk() :

# 你可以在talk中定义另外一个函数
def whisper(word="yes") :
return word.lower()+"...";

# ... 并且立马使用它

print whisper()

# 你每次调用'talk'，定义在talk里面的whisper同样也会被调用
talk()
# 输出 :
# yes...

# 但是"whisper" 不会单独存在:

try :
print whisper()
except NameError, e :
print e
#输出 : "name 'whisper' is not defined"*

函数引用
从以上两个例子我们可以得出，函数既然作为一个对象，因此：
1. 其可以被赋给其他变量
2. 其可以被定义在另外一个函数内
这也就是说，函数可以返回一个函数，看下面的例子：

def getTalk(type="shout") :

# 我们定义另外一个函数
def shout(word="yes") :
return word.capitalize()+" !"

def whisper(word="yes") :
return word.lower()+"...";

# 然后我们返回其中一个
if type == "shout" :
# 我们没有使用(),因为我们不是在调用该函数
# 我们是在返回该函数
return shout
else :
return whisper

# 然后怎么使用呢 ?

# 把该函数赋予某个变量
talk = getTalk()

# 这里你可以看到talk其实是一个函数对象:
print talk
#输出 : <function shout at 0xb7ea817c>

# 该对象由函数返回的其中一个对象:
print talk()

# 或者你可以直接如下调用 :
print getTalk("whisper")()
#输出 : yes...

还有，既然可以返回一个函数，我们可以把它作为参数传递给函数：

def doSomethingBefore(func) :
print "I do something before then I call the function you gave me"
print func()

doSomethingBefore(scream)
#输出 :
#I do something before then I call the function you gave me
#Yes !

这里你已经足够能理解装饰器了，其他它可被视为封装器。也就是说，它能够让你在装饰前后执行代码而无须改变函数本身内容。
手工装饰
那么如何进行手动装饰呢？

# 装饰器是一个函数，而其参数为另外一个函数
def my_shiny_new_decorator(a_function_to_decorate) :

# 在内部定义了另外一个函数：一个封装器。
# 这个函数将原始函数进行封装，所以你可以在它之前或者之后执行一些代码
def the_wrapper_around_the_original_function() :

# 放一些你希望在真正函数执行前的一些代码
print "Before the function runs"

# 执行原始函数
a_function_to_decorate()

# 放一些你希望在原始函数执行后的一些代码
print "After the function runs"

#在此刻，"a_function_to_decrorate"还没有被执行，我们返回了创建的封装函数
#封装器包含了函数以及其前后执行的代码，其已经准备完毕
return the_wrapper_around_the_original_function

# 现在想象下，你创建了一个你永远也不远再次接触的函数
def a_stand_alone_function() :
print "I am a stand alone function, don't you dare modify me"

a_stand_alone_function()
#输出: I am a stand alone function, don't you dare modify me

# 好了，你可以封装它实现行为的扩展。可以简单的把它丢给装饰器
# 装饰器将动态地把它和你要的代码封装起来，并且返回一个新的可用的函数。
a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#输出 :
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

现在你也许要求当每次调用a_stand_alone_function时，实际调用却是a_stand_alone_function_decorated。实现也很简单，可以用my_shiny_new_decorator来给a_stand_alone_function重新赋值。

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#输出 :
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

# And guess what, that's EXACTLY what decorators do !

装饰器揭秘
前面的例子，我们可以使用装饰器的语法：

@my_shiny_new_decorator
def another_stand_alone_function() :
print "Leave me alone"

another_stand_alone_function()
#输出 :
#Before the function runs
#Leave me alone
#After the function runs

当然你也可以累积装饰：

def bread(func) :
def wrapper() :
print "</''''''\>"
func()
print "<\______/>"
return wrapper

def ingredients(func) :
def wrapper() :
print "#tomatoes#"
func()
print "~salad~"
return wrapper

def sandwich(food="--ham--") :
print food

sandwich()
#输出 : --ham--
sandwich = bread(ingredients(sandwich))
sandwich()
#outputs :
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>

使用python装饰器语法：

@bread
@ingredients
def sandwich(food="--ham--") :
print food

sandwich()
#输出 :
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>