mybatis-mapper-problem

Eclipse配置MyBatis的xml自动提示:
在配置config.xml的时候还有提示,但是配置mapper.xml的时候xml不能自动提示了.
config.xml的头部:

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

mapper.xml的头部:

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

解决:
按着ctrl键点击 http://mybatis.org/dtd/mybatis-3-mapper.dtd,将dtd文件下载到本机上存好。下载不了就说明这个url有问题,网上找一下吧.

eclipse中 , window–>Preferences–>XML–>XML catalog , 然后点击add,选择Category Entity, Location填写本地dtd文件路径,key type用public-id,key复制xml头上的-//mybatis.org//DTD Config 3.0//EN这一部分,Alternative web Address填写dtd文件网络地址,然后确定保存,再返回xml文件,你就会发现自动提示能用啦!

发表在 java | 标签为 | 留下评论

python第三方库安装技巧

from:Python第三方库安装技巧

Python 是一门优雅的语言,简洁的语法,强大的功能。当然丰富的第三方库,更能加速开发。那么问题来了,如何安装这些第三方库(包)呢?

安装第三方库的方式其实不多。下面就介绍一些技巧。

源码安装

很多第三方库都是开源的,几乎都可以在github 或者 pypi上找到源码。找到源码格式大概都是 ziptar.ziptar.bz2格式的压缩包。解压这些包,进入解压好的文件夹,通常会看见一个 setup.py 的文件。打开命令行,进入该文件夹。运行

python setup.py install

这个命令,就能把这个第三库安装到系统里,也就是你的 Python 路径,windows大概是在 C:\Python2.7\Lib\site-packages
Linux会在 /usr/local/lib/python2.7/dist-packages
Mac 应该在 /Library/Python/2.7/site-packages。如果是在 virtulenv环境下安装,这个包就被安装在所建立的虚拟环境下的 site-packages/目录下。想要卸载这些库也很简单,进入 site-packages,直接删掉库文件就 OK 啦。当然,这些安装可能有一点麻烦,需要下载,解压,再运行安装,卸载也不是很方便。有没有一种工具,可以帮外面管理这些库呢?

包管理器 (pip 和 easy_install)

现在很多编程语言,都带有包管理器,例如 RubygemnodejsnpmPython当然也不例外,拥有大名鼎鼎的 pipeasy_install

前面说到的pypi就是一些 python第三库所在的源,使用 pip 或者 easy_install 安装模块,会搜索这个源,然后自动下载安装。比如我们需要安装 flask 框架具体命令如下:

pip install flask

或者

easy_install flask

简单吧,一个简单的命令就搞定。卸载也很方便,例如我们需要卸载flask

pip uninstall flask

查看所安装的包,包括系统自带的和手动安装的

pip list

还可以搜索包

pip search flask

还可以重定向输出项目使用的库。

pip freeze > requirements.txt

这样就会把该环境下的第三方库重定向到 requirements.txt文件内,如果给别人安装项目的依赖,只需要运行:

pip install -r requirements.txt

很方便吧。当然,有时候,我们的网络并不是那么顺畅,pip是在线安装的,可不可以离线呢?当然可以啦,pip install 的第一步,就是在 pypi 上寻找包,然后下载到本地。如果网络不好,可以先建一个本地的仓库,把常用的包离线下载。比如可以下载 flask 的源码

pip intall flask-master.zip

同样也可以安装。

最新版本的pip也支持git安装,只需要使用其git地址就行

pip install git+https://github.com/kennethreitz/requests.git

不过这种安装方式相当的慢。它的原来就是先clone到本地的临时目录,然后再安装zip包。

虚拟环境相关安装

当然,上面介绍的,其实也是很普通很常见的方式,也算不上什么技巧。下面介绍的,则是一些需要了解原理和解决非常规问题的技巧。

使用Python,我们会喜欢用 virtualenv建立虚拟环境,例如建立一个 venv的虚拟环境。我们只需要 source进去就可以使用pip安装了。可是有时候,即使在虚拟环境下,使用了sudo的前缀(windows忽略),那么安装的库不是在虚拟环境,而是被安装到系统下的site-package 目录下了。

windows的用户可能会很开心,不需要注意这个问题。当然 windows 也同样有着自己的问题。在 windows上安装python,一般是编译好的二进制包exe可执行文件。通常有 32位和64位的python。对于第三方库,本来32和64不会有太大的差别。但是对于一些C写的python库,如mysqldbPILpillow,会发现使用 pip或者 easy_install 的方式会报错:

Fixing python error: Unable to find vcvarsall.bat

原因大概是 windows上缺少一些 C编译器东东。源码需要编译一下才能安装,此时 windows就很苦逼了。当然,有一些好心人,帮您把常用的一些库编译成 exe 可执行文件,放到了这个站点。你只需要寻找对于版本的,下载一键安装。

可是,还有一个问题,下载 exe 文件,运行安装,这个库是被安装到了系统的 site-package 目录下,如果我在windows 建立了venv虚拟环境,这样安装不是歇菜了么?

别担心,这个文章的真正技巧,就是为了解决这个问题的。我们来安装64位的 mysqldb。先下载 MySQL‑python‑1.2.5.win‑amd64‑py2.7.exewindows 上,用命令行进入虚拟环境 venv。然后运行

 easy_install MySQLpython‑1.2.5.winamd64py2.7.exe

完美解决,在 venv 虚拟环境,将mysqldb 库安装到了venv下。

有了上面三个方式,几乎涵盖 python 所有平台的第三方库安装。不过话说回来,尽管 Python 是跨平台,开发环境,还是尽量使用 Linux或者MacOS,这两个系统有更好的工具以及省去很多莫名其妙的问题。

发表在 python | 标签为 , | 留下评论

python-深入

Python深入01 特殊方法与多范式

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。

 

Python一切皆对象,但同时,Python还是一个多范式语言(multi-paradigm),你不仅可以使用面向对象的方式来编写程序,还可以用面向过程的方式来编写相同功能的程序(还有函数式、声明式等,我们暂不深入)。Python的多范式依赖于Python对象中的特殊方法(special method)。

特殊方法名的前后各有两个下划线。特殊方法又被成为魔法方法(magic method),定义了许多Python语法和表达方式,正如我们在下面的例子中将要看到的。当对象中定义了特殊方法的时候,Python也会对它们有“特殊优待”。比如定义了__init__()方法的类,会在创建对象的时候自动执行__init__()方法中的操作。

(可以通过dir()来查看对象所拥有的特殊方法,比如dir(1))

运算符

Python的运算符是通过调用对象的特殊方法实现的。比如:

'abc' + 'xyz'               # 连接字符串

实际执行了如下操作:

'abc'.__add__('xyz')

所以,在Python中,两个对象是否能进行加法运算,首先就要看相应的对象是否有__add__()方法。一旦相应的对象有__add__()方法,即使这个对象从数学上不可加,我们都可以用加法的形式,来表达obj.__add__()所定义的操作。在Python中,运算符起到简化书写的功能,但它依靠特殊方法实现。

Python不强制用户使用面向对象的编程方法。用户可以选择自己喜欢的使用方式(比如选择使用+符号,还是使用更加面向对象的__add__()方法)。特殊方法写起来总是要更费事一点。

尝试下面的操作,看看效果,再想想它的对应运算符

(1.8).__mul__(2.0)

True.__or__(False)

 

内置函数

与运算符类似,许多内置函数也都是调用对象的特殊方法。比如

len([1,2,3])      # 返回表中元素的总数

实际上做的是

[1,2,3].__len__()

相对与__len__(),内置函数len()也起到了简化书写的作用。

尝试下面的操作,想一下它的对应内置函数

(-1).__abs__()

(2.3).__int__()

 

表(list)元素引用

下面是我们常见的表元素引用方式

li = [1, 2, 3, 4, 5, 6]
print(li[3])

上面的程序运行到li[3]的时候,Python发现并理解[]符号,然后调用__getitem__()方法。

li = [1, 2, 3, 4, 5, 6]
print(li.__getitem__(3))

尝试看下面的操作,想想它的对应

li.__setitem__(3, 0)

{‘a’:1, ‘b’:2}.__delitem__(‘a’)

函数

我们已经说过,在Python中,函数也是一种对象。实际上,任何一个有__call__()特殊方法的对象都被当作是函数。比如下面的例子:

复制代码
class SampleMore(object):
    def __call__(self, a):
        return a + 5
add = SampleMore()     # A function object
print(add(2))          # Call function    
map(add, [2, 4, 5])    # Pass around function object
复制代码

add为SampleMore类的一个对象,当被调用时,add执行加5的操作。add还可以作为函数对象,被传递给map()函数。

当然,我们还可以使用更“优美”的方式,想想是什么。

 

总结

对于内置的对象来说(比如整数、表、字符串等),它们所需要的特殊方法都已经在Python中准备好了。而用户自己定义的对象也可以通过增加特殊方法,来实现自定义的语法。特殊方法比较靠近Python的底层,许多Python功能的实现都要依赖于特殊方法。我们将在以后看到更多的例子。

大黄蜂,还是Camaro跑车

Python的许多语法都是基于其面向对象模型的封装。对象模型是Python的骨架,是功能完备、火力强大的大黄蜂。但是Python也提供更加简洁的语法,让你使用不同的编程形态,从而在必要时隐藏一些面向对象的接口。正如我们看到的Camaro跑车,将自己威风的火药库收起来,提供方便人类使用的车门和座椅。

Python深入02 上下文管理器

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

上下文管理器(context manager)是Python2.5开始支持的一种语法,用于规定某个对象的使用范围。一旦进入或者离开该使用范围,会有特殊操作被调用 (比如为对象分配或者释放内存)。它的语法形式是with…as…

 

关闭文件

我们会进行这样的操作:打开文件,读写,关闭文件。程序员经常会忘记关闭文件。上下文管理器可以在不需要文件的时候,自动关闭文件。

下面我们看一下两段程序:

# without context manager
f = open("new.txt", "w")
print(f.closed)               # whether the file is open
f.write("Hello World!")
f.close()
print(f.closed)

以及:

# with context manager
with open("new.txt", "w") as f:
    print(f.closed)
    f.write("Hello World!")
print(f.closed)

两段程序实际上执行的是相同的操作。我们的第二段程序就使用了上下文管理器 (with…as…)。上下文管理器有隶属于它的程序块。当隶属的程序块执行结束的时候(也就是不再缩进),上下文管理器自动关闭了文件 (我们通过f.closed来查询文件是否关闭)。我们相当于使用缩进规定了文件对象f的使用范围。

 

上面的上下文管理器基于f对象的__exit__()特殊方法(还记得我们如何利用特殊方法来实现各种语法?参看特殊方法与多范式)。当我们使用上下文管理器的语法时,我们实际上要求Python在进入程序块之前调用对象的__enter__()方法,在结束程序块的时候调用__exit__()方法。对于文件对象f来说,它定义了__enter__()和__exit__()方法(可以通过dir(f)看到)。在f的__exit__()方法中,有self.close()语句。所以在使用上下文管理器时,我们就不用明文关闭f文件了。

 

自定义

任何定义了__enter__()和__exit__()方法的对象都可以用于上下文管理器。文件对象f是内置对象,所以f自动带有这两个特殊方法,不需要自定义。

下面,我们自定义用于上下文管理器的对象,就是下面的myvow:

 

复制代码
# customized object

class VOW(object):
    def __init__(self, text):
        self.text = text
    def __enter__(self):
        self.text = "I say: " + self.text    # add prefix
        return self                          # note: return an object
    def __exit__(self,exc_type,exc_value,traceback):
        self.text = self.text + "!"          # add suffix


with VOW("I'm fine") as myvow:
    print(myvow.text)

print(myvow.text)
复制代码

 

我们的运行结果如下:

I say: I'm fine
I say: I'm fine!

我们可以看到,在进入上下文和离开上下文时,对象的text属性发生了改变(最初的text属性是”I’m fine”)。

__enter__()返回一个对象。上下文管理器会使用这一对象作为as所指的变量,也就是myvow。在__enter__()中,我们为myvow.text增加了前缀 (“I say: “)。在__exit__()中,我们为myvow.text增加了后缀(“!”)。

注意: __exit__()中有四个参数。当程序块中出现异常(exception),__exit__()的参数中exc_type, exc_value, traceback用于描述异常。我们可以根据这三个参数进行相应的处理。如果正常运行结束,这三个参数都是None。在我们的程序中,我们并没有用到这一特性。

 

总结:

通过上下文管理器,我们控制对象在程序不同区间的特性。上下文管理器(with EXPR as VAR)大致相当于如下流程:

复制代码
# with EXPR as VAR:

VAR = EXPR
VAR = VAR.__enter__()
try:
    BLOCK
finally:
    VAR.__exit__()
复制代码

由于上下文管理器带来的便利,它是一个值得使用的工具。

Python深入03 对象的属性

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

Python一切皆对象(object),每个对象都可能有多个属性(attribute)。Python的属性有一套统一的管理方案。

 

属性的__dict__系统

对象的属性可能来自于其类定义,叫做类属性(class attribute)。类属性可能来自类定义自身,也可能根据类定义继承来的。一个对象的属性还可能是该对象实例定义的,叫做对象属性(object attribute)。

对象的属性储存在对象的__dict__属性中。__dict__为一个词典,键为属性名,对应的值为属性本身。我们看下面的类和对象。chicken类继承自bird类,而summer为chicken类的一个对象。

复制代码
class bird(object):
    feather = True

class chicken(bird):
    fly = False
    def __init__(self, age):
        self.age = age

summer = chicken(2)

print(bird.__dict__)
print(chicken.__dict__)
print(summer.__dict__)
复制代码

 

下面为我们的输出结果:

复制代码
{'__dict__': <attribute '__dict__' of 'bird' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'bird' objects>, 'feather': True, '__doc__': None}


{'fly': False, '__module__': '__main__', '__doc__': None, '__init__': <function __init__ at 0x2b91db476d70>}


{'age': 2}
复制代码

 

第一行为bird类的属性,比如feather。第二行为chicken类的属性,比如fly和__init__方法。第三行为summer对象的属性,也就是age。有一些属性,比如__doc__,并不是由我们定义的,而是由Python自动生成。此外,bird类也有父类,是object类(正如我们的bird定义,class bird(object))。这个object类是Python中所有类的父类。

可以看到,Python中的属性是分层定义的,比如这里分为object/bird/chicken/summer这四层。当我们需要调用某个属性的时候,Python会一层层向上遍历,直到找到那个属性。(某个属性可能出现再不同的层被重复定义,Python向上的过程中,会选取先遇到的那一个,也就是比较低层的属性定义)。

当我们有一个summer对象的时候,分别查询summer对象、chicken类、bird类以及object类的属性,就可以知道summer对象所有的__dict__,就可以找到通过对象summer可以调用和修改的所有属性了。下面两种属性修改方法等效:

summer.__dict__['age'] = 3
print(summer.__dict__['age'])

summer.age = 5
print(summer.age)

 

(上面的情况中,我们已经知道了summer对象的类为chicken,而chicken类的父类为bird。如果只有一个对象,而不知道它的类以及其他信息的时候,我们可以利用__class__属性找到对象的类,然后调用类的__base__属性来查询父类)

 

特性

同一个对象的不同属性之间可能存在依赖关系。当某个属性被修改时,我们希望依赖于该属性的其他属性也同时变化。这时,我们不能通过__dict__的方式来静态的储存属性。Python提供了多种即时生成属性的方法。其中一种称为特性(property)。特性是特殊的属性。比如我们为chicken类增加一个特性adult。当对象的age超过1时,adult为True;否则为False:

复制代码
class bird(object):
    feather = True

class chicken(bird):
    fly = False
    def __init__(self, age):
        self.age = age
    def getAdult(self):
        if self.age > 1.0: return True
        else: return False
    adult = property(getAdult)   # property is built-in

summer = chicken(2)

print(summer.adult)
summer.age = 0.5
print(summer.adult)
复制代码

 

特性使用内置函数property()来创建。property()最多可以加载四个参数。前三个参数为函数,分别用于处理查询特性、修改特性、删除特性。最后一个参数为特性的文档,可以为一个字符串,起说明作用。

 

我们使用下面一个例子进一步说明:

复制代码
class num(object):
    def __init__(self, value):
        self.value = value
    def getNeg(self):
        return -self.value
    def setNeg(self, value):
        self.value = -value
    def delNeg(self):
        print("value also deleted")
        del self.value
    neg = property(getNeg, setNeg, delNeg, "I'm negative")

x = num(1.1)
print(x.neg)
x.neg = -22
print(x.value)
print(num.neg.__doc__)
del x.neg
复制代码

 

上面的num为一个数字,而neg为一个特性,用来表示数字的负数。当一个数字确定的时候,它的负数总是确定的;而当我们修改一个数的负数时,它本身的值也应该变化。这两点由getNeg和setNeg来实现。而delNeg表示的是,如果删除特性neg,那么应该执行的操作是删除属性value。property()的最后一个参数(“I’m negative”)为特性negative的说明文档。

 

使用特殊方法__getattr__

我们可以用__getattr__(self, name)来查询即时生成的属性。当我们查询一个属性时,如果通过__dict__方法无法找到该属性,那么Python会调用对象的__getattr__方法,来即时生成该属性。比如:

复制代码
class bird(object):
    feather = True

class chicken(bird):
    fly = False
    def __init__(self, age):
        self.age = age
    def __getattr__(self, name):
        if name == 'adult':
            if self.age > 1.0: return True
            else: return False
        else: raise AttributeError(name)

summer = chicken(2)

print(summer.adult)
summer.age = 0.5
print(summer.adult)

print(summer.male)
复制代码

 

每个特性需要有自己的处理函数,而__getattr__可以将所有的即时生成属性放在同一个函数中处理。__getattr__可以根据函数名区别处理不同的属性。比如上面我们查询属性名male的时候,raise AttributeError。

(Python中还有一个__getattribute__特殊方法,用于查询任意属性。__getattr__只能用来查询不在__dict__系统中的属性)

__setattr__(self, name, value)和__delattr__(self, name)可用于修改和删除属性。它们的应用面更广,可用于任意属性。

 

即时生成属性的其他方式

即时生成属性还可以使用其他的方式,比如descriptor(descriptor类实际上是property()函数的底层,property()实际上创建了一个该类的对象)。有兴趣可以进一步查阅。

 

总结

__dict__分层存储属性。每一层的__dict__只存储该层新增的属性。子类不需要重复存储父类中的属性。

即时生成属性是值得了解的概念。在Python开发中,你有可能使用这种方法来更合理的管理对象的属性。

Python深入04 闭包

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

闭包(closure)是函数式编程的重要的语法结构。函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。在面向过程编程中,我们见到过函数(function);在面向对象编程中,我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式组织代码,并提高代码的可重复使用性(reusability)。闭包也是一种组织代码的结构,它同样提高了代码的可重复使用性。

不同的语言实现闭包的方式不同。Python以函数对象为基础,为闭包这一语法结构提供支持的 (我们在特殊方法与多范式中,已经多次看到Python使用对象来实现一些特殊的语法)。Python一切皆对象,函数这一语法结构也是一个对象。在函数对象中,我们像使用一个普通对象一样使用函数对象,比如更改函数对象的名字,或者将函数对象作为参数进行传递。

 

函数对象的作用域

和其他对象一样,函数对象也有其存活的范围,也就是函数对象的作用域。函数对象是使用def语句定义的,函数对象的作用域与def所在的层级相同。比如下面代码,我们在line_conf函数的隶属范围内定义的函数line,就只能在line_conf的隶属范围内调用。

复制代码
def line_conf():
    def line(x):
        return 2*x+1
    print(line(5))   # within the scope


line_conf()
print(line(5))       # out of the scope
复制代码

line函数定义了一条直线(y = 2x + 1)。可以看到,在line_conf()中可以调用line函数,而在作用域之外调用line将会有下面的错误:

NameError: name ‘line’ is not defined

说明这时已经在作用域之外。

 

同样,如果使用lambda定义函数,那么函数对象的作用域与lambda所在的层级相同。

 

闭包

函数是一个对象,所以可以作为某个函数的返回结果。

复制代码
def line_conf():
    def line(x):
        return 2*x+1
    return line       # return a function object

my_line = line_conf()
print(my_line(5))
复制代码

上面的代码可以成功运行。line_conf的返回结果被赋给line对象。上面的代码将打印11。

 

如果line()的定义中引用了外部的变量,会发生什么呢?

复制代码
def line_conf():
    b = 15
    def line(x):
        return 2*x+b
    return line       # return a function object

b = 5
my_line = line_conf()
print(my_line(5))
复制代码

我们可以看到,line定义的隶属程序块中引用了高层级的变量b,但b信息存在于line的定义之外 (b的定义并不在line的隶属程序块中)。我们称b为line的环境变量。事实上,line作为line_conf的返回值时,line中已经包括b的取值(尽管b并不隶属于line)。

上面的代码将打印25,也就是说,line所参照的b值是函数对象定义时可供参考的b值,而不是使用时的b值。

 

一个函数和它的环境变量合在一起,就构成了一个闭包(closure)。在Python中,所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的__closure__属性中。比如下面的代码:

复制代码
def line_conf():
    b = 15
    def line(x):
        return 2*x+b
    return line       # return a function object

b = 5
my_line = line_conf()
print(my_line.__closure__)
print(my_line.__closure__[0].cell_contents)
复制代码

__closure__里包含了一个元组(tuple)。这个元组中的每个元素是cell类型的对象。我们看到第一个cell包含的就是整数15,也就是我们创建闭包时的环境变量b的取值。

 

下面看一个闭包的实际例子:

复制代码
def line_conf(a, b):
    def line(x):
        return ax + b
    return line

line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5), line2(5))
复制代码

这个例子中,函数line与环境变量a,b构成闭包。在创建闭包的时候,我们通过line_conf的参数a,b说明了这两个环境变量的取值,这样,我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b,就可以获得不同的直线表达函数。由此,我们可以看到,闭包也具有提高代码可复用性的作用。

如果没有闭包,我们需要每次创建直线函数的时候同时说明a,b,x。这样,我们就需要更多的参数传递,也减少了代码的可移植性。利用闭包,我们实际上创建了泛函。line函数定义一种广泛意义的函数。这个函数的一些方面已经确定(必须是直线),但另一些方面(比如a和b参数待定)。随后,我们根据line_conf传递来的参数,通过闭包的形式,将最终函数确定下来。

 

闭包与并行运算

闭包有效的减少了函数所需定义的参数数目。这对于并行运算来说有重要的意义。在并行运算的环境下,我们可以让每台电脑负责一个函数,然后将一台电脑的输出和下一台电脑的输入串联起来。最终,我们像流水线一样工作,从串联的电脑集群一端输入数据,从另一端输出数据。这样的情境最适合只有一个参数输入的函数。闭包就可以实现这一目的。

并行运算正称为一个热点。这也是函数式编程又热起来的一个重要原因。函数式编程早在1950年代就已经存在,但应用并不广泛。然而,我们上面描述的流水线式的工作并行集群过程,正适合函数式编程。由于函数式编程这一天然优势,越来越多的语言也开始加入对函数式编程范式的支持。

Python深入05 装饰器

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

装饰器(decorator)是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中,我们有多种方法对函数和类进行加工,比如在Python闭包中,我们见到函数对象作为某一个函数的返回结果。相对于其它方式,装饰器语法简单,代码可读性高。因此,装饰器在Python项目中有广泛的应用。

装饰器最早在Python 2.5中出现,它最初被用于加工函数和方法这样的可调用对象(callable object,这样的对象定义有__call__方法)。在Python 2.6以及之后的Python版本中,装饰器被进一步用于加工类。

 

装饰函数和方法

我们先定义两个简单的数学函数,一个用来计算平方和,一个用来计算平方差:

复制代码
# get square sum
def square_sum(a, b):
    return a**2 + b**2

# get square diff
def square_diff(a, b):
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))
复制代码

在拥有了基本的数学功能之后,我们可能想为函数增加其它的功能,比如打印输入。我们可以改写函数来实现这一点:

复制代码
# modify: print input

# get square sum
def square_sum(a, b):
    print("intput:", a, b)
    return a**2 + b**2

# get square diff
def square_diff(a, b):
    print("input", a, b)
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))
复制代码

我们修改了函数的定义,为函数增加了功能。

 

现在,我们使用装饰器来实现上述修改:

复制代码
def decorator(F):
    def new_F(a, b):
        print("input", a, b)
        return F(a, b)
    return new_F

# get square sum
@decorator
def square_sum(a, b):
    return a**2 + b**2

# get square diff
@decorator
def square_diff(a, b):
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))
复制代码

装饰器可以用def的形式定义,如上面代码中的decorator。装饰器接收一个可调用对象作为输入参数,并返回一个新的可调用对象。装饰器新建了一个可调用对象,也就是上面的new_F。new_F中,我们增加了打印的功能,并通过调用F(a, b)来实现原有函数的功能。

定义好装饰器后,我们就可以通过@语法使用了。在函数square_sum和square_diff定义之前调用@decorator,我们实际上将square_sum或square_diff传递给decorator,并将decorator返回的新的可调用对象赋给原来的函数名(square_sum或square_diff)。 所以,当我们调用square_sum(3, 4)的时候,就相当于:

square_sum = decorator(square_sum)
square_sum(3, 4)

我们知道,Python中的变量名和对象是分离的。变量名可以指向任意一个对象。从本质上,装饰器起到的就是这样一个重新指向变量名的作用(name binding),让同一个变量名指向一个新返回的可调用对象,从而达到修改可调用对象的目的。

与加工函数类似,我们可以使用装饰器加工类的方法。

 

如果我们有其他的类似函数,我们可以继续调用decorator来修饰函数,而不用重复修改函数或者增加新的封装。这样,我们就提高了程序的可重复利用性,并增加了程序的可读性。

 

含参的装饰器

在上面的装饰器调用中,比如@decorator,该装饰器默认它后面的函数是唯一的参数。装饰器的语法允许我们调用decorator时,提供其它参数,比如@decorator(a)。这样,就为装饰器的编写和使用提供了更大的灵活性。

复制代码
# a new wrapper layer
def pre_str(pre=''):
    # old decorator
    def decorator(F):
        def new_F(a, b):
            print(pre + "input", a, b)
            return F(a, b)
        return new_F
    return decorator

# get square sum
@pre_str('^_^')
def square_sum(a, b):
    return a**2 + b**2

# get square diff
@pre_str('T_T')
def square_diff(a, b):
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))
复制代码

上面的pre_str是允许参数的装饰器。它实际上是对原有装饰器的一个函数封装,并返回一个装饰器。我们可以将它理解为一个含有环境参量的闭包。当我们使用@pre_str(‘^_^’)调用的时候,Python能够发现这一层的封装,并把参数传递到装饰器的环境中。该调用相当于:

square_sum = pre_str('^_^') (square_sum)

 

装饰类

在上面的例子中,装饰器接收一个函数,并返回一个函数,从而起到加工函数的效果。在Python 2.6以后,装饰器被拓展到类。一个装饰器可以接收一个类,并返回一个类,从而起到加工类的效果。

复制代码
def decorator(aClass):
    class newClass:
        def __init__(self, age):
            self.total_display   = 0
            self.wrapped         = aClass(age)
        def display(self):
            self.total_display += 1
            print("total display", self.total_display)
            self.wrapped.display()
    return newClass

@decorator
class Bird:
    def __init__(self, age):
        self.age = age
    def display(self):
        print("My age is",self.age)

eagleLord = Bird(5)
for i in range(3):
    eagleLord.display()
复制代码

在decorator中,我们返回了一个新类newClass。在新类中,我们记录了原来类生成的对象(self.wrapped),并附加了新的属性total_display,用于记录调用display的次数。我们也同时更改了display方法。

通过修改,我们的Bird类可以显示调用display的次数了。

 

总结

装饰器的核心作用是name binding。这种语法是Python多编程范式的又一个体现。大部分Python用户都不怎么需要定义装饰器,但有可能会使用装饰器。鉴于装饰器在Python项目中的广泛使用,了解这一语法是非常有益的。

Python深入06 Python的内存管理

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

语言的内存管理是语言设计的一个重要方面。它是决定语言性能的重要因素。无论是C语言的手工管理,还是Java的垃圾回收,都成为语言最重要的特征。这里以Python语言为例子,说明一门动态类型的、面向对象的语言的内存管理方式。

 

对象的内存使用

赋值语句是语言最常见的功能了。但即使是最简单的赋值语句,也可以很有内涵。Python的赋值语句就很值得研究。

a = 1

整数1为一个对象。而a是一个引用。利用赋值语句,引用a指向对象1。Python是动态类型的语言(参考动态类型),对象与引用分离。Python像使用“筷子”那样,通过引用来接触和翻动真正的食物——对象。

 

引用和对象

 

为了探索对象在内存的存储,我们可以求助于Python的内置函数id()。它用于返回对象的身份(identity)。其实,这里所谓的身份,就是该对象的内存地址。

a = 1

print(id(a))
print(hex(id(a)))

在我的计算机上,它们返回的是:

11246696
‘0xab9c68’

分别为内存地址的十进制和十六进制表示。

 

在Python中,整数和短小的字符,Python都会缓存这些对象,以便重复使用。当我们创建多个等于1的引用时,实际上是让所有这些引用指向同一个对象。

a = 1
b = 1

print(id(a))
print(id(b))

上面程序返回

11246696

11246696

可见a和b实际上是指向同一个对象的两个引用。

 

为了检验两个引用指向同一个对象,我们可以用is关键字。is用于判断两个引用所指的对象是否相同。

复制代码
# True
a = 1
b = 1
print(a is b)

# True
a = "good"
b = "good"
print(a is b)

# False
a = "very good morning"
b = "very good morning"
print(a is b)

# False
a = []
b = []
print(a is b)
复制代码

上面的注释为相应的运行结果。可以看到,由于Python缓存了整数和短字符串,因此每个对象只存有一份。比如,所有整数1的引用都指向同一对象。即使使用赋值语句,也只是创造了新的引用,而不是对象本身。长的字符串和其它对象可以有多个相同的对象,可以使用赋值语句创建出新的对象。

 

在Python中,每个对象都有存有指向该对象的引用总数,即引用计数(reference count)。

我们可以使用sys包中的getrefcount(),来查看某个对象的引用计数。需要注意的是,当使用某个引用作为参数,传递给getrefcount()时,参数实际上创建了一个临时的引用。因此,getrefcount()所得到的结果,会比期望的多1。

复制代码
from sys import getrefcount

a = [1, 2, 3]
print(getrefcount(a))

b = a
print(getrefcount(b))
复制代码

由于上述原因,两个getrefcount将返回2和3,而不是期望的1和2。

 

对象引用对象

Python的一个容器对象(container),比如表、词典等,可以包含多个对象。实际上,容器对象中包含的并不是元素对象本身,是指向各个元素对象的引用。

我们也可以自定义一个对象,并引用其它对象:

复制代码
class from_obj(object):
    def __init__(self, to_obj):
        self.to_obj = to_obj

b = [1,2,3]
a = from_obj(b)
print(id(a.to_obj))
print(id(b))
复制代码

可以看到,a引用了对象b。

 

对象引用对象,是Python最基本的构成方式。即使是a = 1这一赋值方式,实际上是让词典的一个键值”a”的元素引用整数对象1。该词典对象用于记录所有的全局引用。该词典引用了整数对象1。我们可以通过内置函数globals()来查看该词典。

 

当一个对象A被另一个对象B引用时,A的引用计数将增加1。

复制代码
from sys import getrefcount

a = [1, 2, 3]
print(getrefcount(a))

b = [a, a]
print(getrefcount(a))
复制代码

由于对象b引用了两次a,a的引用计数增加了2。

 

容器对象的引用可能构成很复杂的拓扑结构。我们可以用objgraph包来绘制其引用关系,比如

x = [1, 2, 3]
y = [x, dict(key1=x)]
z = [y, (x, y)]

import objgraph
objgraph.show_refs([z], filename='ref_topo.png')

 

 

objgraph是Python的一个第三方包。安装之前需要安装xdot。

sudo apt-get install xdot
sudo pip install objgraph

objgraph官网

 

两个对象可能相互引用,从而构成所谓的引用环(reference cycle)。

a = []
b = [a]
a.append(b)

即使是一个对象,只需要自己引用自己,也能构成引用环。

a = []
a.append(a)
print(getrefcount(a))

引用环会给垃圾回收机制带来很大的麻烦,我将在后面详细叙述这一点。

 

引用减少

某个对象的引用计数可能减少。比如,可以使用del关键字删除某个引用:

复制代码
from sys import getrefcount

a = [1, 2, 3]
b = a
print(getrefcount(b))

del a
print(getrefcount(b))
复制代码

 

del也可以用于删除容器元素中的元素,比如:

a = [1,2,3]
del a[0]
print(a)

 

 

如果某个引用指向对象A,当这个引用被重新定向到某个其他对象B时,对象A的引用计数减少:

复制代码
from sys import getrefcount

a = [1, 2, 3]
b = a
print(getrefcount(b))

a = 1
print(getrefcount(b))
复制代码

 

 

垃圾回收

吃太多,总会变胖,Python也是这样。当Python中的对象越来越多,它们将占据越来越大的内存。不过你不用太担心Python的体形,它会乖巧的在适当的时候“减肥”,启动垃圾回收(garbage collection),将没用的对象清除。在许多语言中都有垃圾回收机制,比如Java和Ruby。尽管最终目的都是塑造苗条的提醒,但不同语言的减肥方案有很大的差异 (这一点可以对比本文和Java内存管理与垃圾回收

)。

从基本原理上,当Python的某个对象的引用计数降为0时,说明没有任何引用指向该对象,该对象就成为要被回收的垃圾了。比如某个新建对象,它被分配给某个引用,对象的引用计数变为1。如果引用被删除,对象的引用计数为0,那么该对象就可以被垃圾回收。比如下面的表:

a = [1, 2, 3]
del a

del a后,已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里,就成了不健康的脂肪。当垃圾回收启动时,Python扫描到这个引用计数为0的对象,就将它所占据的内存清空。

 

然而,减肥是个昂贵而费力的事情。垃圾回收时,Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多,就没有必要总启动垃圾回收。所以,Python只会在特定条件下,自动启动垃圾回收。当Python运行时,会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时,垃圾回收才会启动。

我们可以通过gc模块的get_threshold()方法,查看该阈值:

import gc
print(gc.get_threshold())

返回(700, 10, 10),后面的两个10是与分代回收相关的阈值,后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。

 

我们也可以手动启动垃圾回收,即使用gc.collect()。

 

分代回收

Python同时采用了分代(generation)回收的策略。这一策略的基本假设是,存活时间越久的对象,越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象,许多对象很快产生和消失,但也有一些对象长期被使用。出于信任和效率,对于这样一些“长寿”对象,我们相信它们的用处,所以减少在垃圾回收中扫描它们的频率。

小家伙要多检查

 

Python将所有的对象分为0,1,2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收,依然存活,那么它就被归入下一代对象。垃圾回收启动时,一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收,那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后,那么会启动对0,1,2,即对所有对象进行扫描。

这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说,每10次0代垃圾回收,会配合1次1代的垃圾回收;而每10次1代的垃圾回收,才会有1次的2代垃圾回收。

同样可以用set_threshold()来调整,比如对2代对象进行更频繁的扫描。

import gc
gc.set_threshold(700, 10, 5)

 

孤立的引用环

引用环的存在会给上面的垃圾回收机制带来很大的困难。这些引用环可能构成无法使用,但引用计数不为0的一些对象。

a = []
b = [a]
a.append(b)

del a
del b

上面我们先创建了两个表对象,并引用对方,构成一个引用环。删除了a,b引用之后,这两个对象不可能再从程序中调用,就没有什么用处了。但是由于引用环的存在,这两个对象的引用计数都没有降到0,不会被垃圾回收。

孤立的引用环

 

为了回收这样的引用环,Python复制每个对象的引用计数,可以记为gc_ref。假设,每个对象i,该计数为gc_ref_i。Python会遍历所有的对象i。对于每个对象i引用的对象j,将相应的gc_ref_j减1。

 

遍历后的结果

 

在结束遍历后,gc_ref不为0的对象,和这些对象引用的对象,以及继续更下游引用的对象,需要被保留。而其它的对象则被垃圾回收。

 

总结

Python作为一种动态类型的语言,其对象和引用分离。这与曾经的面向过程语言有很大的区别。为了有效的释放内存,Python内置了垃圾回收的支持。Python采取了一种相对简单的垃圾回收机制,即引用计数,并因此需要解决孤立引用环的问题。Python与其它语言既有共通性,又有特别的地方。对该内存管理机制的理解,是提高Python性能的重要一步。

发表在 python | 标签为 | 留下评论

python-进阶

Python进阶01 词典

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

基础教程介绍了基本概念,特别是对象和类。

进阶教程对基础教程的进一步拓展,说明Python的细节。希望在进阶教程之后,你对Python有一个更全面的认识。

 

之前我们说了,列表是Python里的一个类。一个特定的表,比如说nl = [1,3,8],就是这个类的一个对象。我们可以调用这个对象的一些方法,比如 nl.append(15)。
我们要介绍一个新的类,词典 (dictionary)。与列表相似,词典也可以储存多个元素。这种储存多个元素的对象称为容器(container)。

 

基本概念

常见的创建词典的方法:

>>>dic = {‘tom’:11, ‘sam’:57,’lily’:100}

>>>print type(dic)

词典和表类似的地方,是包含有多个元素,每个元素以逗号分隔。但词典的元素包含有两部分,键和值,常见的是以字符串来表示键,也可以使用数字或者真值来表示键(不可变的对象可以作为键)。值可以是任意对象。键和值两者一一对应。

 

比如上面的例子中,‘tom’对应11,’sam对应57,’lily’对应100

 

与表不同的是,词典的元素没有顺序。你不能通过下标引用元素。词典是通过键来引用。

>>>print dic[‘tom’]

>>>dic[‘tom’] = 30

>>>print dic

 

构建一个新的空的词典:

>>>dic = {}

>>>print dic

 

在词典中增添一个新元素的方法:

>>>dic[‘lilei’] = 99

>>>print dic

这里,我们引用一个新的键,并赋予它对应的值。

 

词典元素的循环调用

dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}
for key in dic:
    print dic[key]

 

在循环中,dict的每个键,被提取出来,赋予给key变量。

通过print的结果,我们可以再次确认,dic中的元素是没有顺序的。

 

词典的常用方法

>>>print dic.keys()           # 返回dic所有的键

>>>print dic.values()         # 返回dic所有的值

>>>print dic.items()          # 返回dic所有的元素(键值对)

>>>dic.clear()                # 清空dic,dict变为{}

 

另外有一个很常用的用法:

>>>del dic[‘tom’]             # 删除 dic 的‘tom’元素

del是Python中保留的关键字,用于删除对象。

 

与表类似,你可以用len()查询词典中的元素总数。

>>>print(len(dic))

 

总结

词典的每个元素是键值对。元素没有顺序。

dic = {‘tom’:11, ‘sam’:57,’lily’:100}

dic[‘tom’] = 99

for key in dic: …

del, len()

Python进阶02 文本文件的输入输出

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

Python具有基本的文本文件读写功能。Python的标准库提供有更丰富的读写功能。

文本文件的读写主要通过open()所构建的文件对象来实现。

创建文件对象

我们打开一个文件,并使用一个对象来表示该文件:

f = open(文件名,模式)

最常用的模式有:

“r”     # 只读

“w”     # 写入

 

比如

>>>f = open(“test.txt”,”r”)

 

文件对象的方法

读取:

content = f.read(N)          # 读取N bytes的数据

content = f.readline()       # 读取一行

content = f.readlines()      # 读取所有行,储存在列表中,每个元素是一行。

写入:

f.write(‘I like apple’)      # 将’I like apple’写入文件

 

关闭文件:

f.close()

 

练习

建立一个record.txt的文档,写入内容如下:

tom, 12, 86
Lee, 15, 99
Lucy, 11, 58
Joseph, 19, 56

再从record.txt中读取文件并打印。

 

 

总结

f    = open(name, “r”)

line = f.readline()

f.write(‘abc’)

f.close()

Python进阶03 模块

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

我们之前看到了函数和对象。从本质上来说,它们都是为了更好的组织已经有的程序,以方便重复利用。

模块(module)也是为了同样的目的。在Python中,一个.py文件就构成一个模块。通过模块,你可以调用其它文件中的程序。

 

引入模块

我们先写一个first.py文件,内容如下:

def laugh():
    print 'HaHaHaHa'

 

再写一个second.py,并引入first中的程序:

import first

for i in range(10):
    first.laugh()

在second.py中,我们使用了first.py中定义的laugh()函数。

 

引入模块后,可以通过模块.对象的方式来调用引入模块中的某个对象。上面例子中,first为引入的模块,laugh()是我们所引入的对象。

Python中还有其它的引入方式,

import a as b             # 引入模块a,并将模块a重命名为b

from a import function1   # 从模块a中引入function1对象。调用a中对象时,我们不用再说明模块,即直接使用function1,而不是a.function1。

from a import *           # 从模块a中引入所有对象。调用a中对象时,我们不用再说明模块,即直接使用对象,而不是a.对象。

这些引用方式,可以方便后面的程序书写。

 

搜索路径

Python会在以下路径中搜索它想要寻找的模块:

  1. 程序所在的文件夹
  2. 标准库的安装路径
  3. 操作系统环境变量PYTHONPATH所包含的路径

 

如果你有自定义的模块,或者下载的模块,可以根据情况放在相应的路径,以便Python可以找到。

 

模块包

可以将功能相似的模块放在同一个文件夹(比如说this_dir)中,构成一个模块包。通过

import this_dir.module

引入this_dir文件夹中的module模块。

 

该文件夹中必须包含一个__init__.py的文件,提醒Python,该文件夹为一个模块包。__init__.py可以是一个空文件。

 

总结

import module

module.object

__init__.py

Python进阶04 函数的参数对应

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置,传递对应的参数。我们将接触更多的参数传递方式。

 

回忆一下位置传递:

def f(a,b,c):
    return a+b+c

print(f(1,2,3))

在调用f时,1,2,3根据位置分别传递给了a,b,c。

 

关键字传递

有些情况下,用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。依然沿用上面f的定义,更改调用方式:

print(f(c=3,b=2,a=1))

 

关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前:

print(f(1,c=3,b=2))

 

参数默认值

在定义函数的时候,使用形如a=19的方式,可以给参数赋予默认值(default)。如果该参数最终没有被传递值,将使用该默认值。

def f(a,b,c=10):
    return a+b+c

print(f(3,2))
print(f(3,2,1))

在第一次调用函数f时, 我们并没有足够的值,c没有被赋值,c将使用默认值10.

第二次调用函数的时候,c被赋值为1,不再使用默认值。

 

包裹传递

在定义函数时,我们有时候并不知道调用的时候会传递多少个参数。这时候,包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会非常有用。

 

下面是包裹位置传递的例子:

def func(*name):
    print type(name)
    print name

func(1,4,6)
func(5,6,7,1,2,3)

两次调用,尽管参数个数不同,都基于同一个func定义。在func的参数表中,所有的参数被name收集,根据位置合并成一个元组(tuple),这就是包裹位置传递。

为了提醒Python参数,name是包裹位置传递所用的元组名,在定义func时,在name前加*号。

 

下面是包裹关键字传递的例子:

def func(**dict):
    print type(dict)
    print dict

func(a=1,b=9)
func(m=2,n=1,c=11)

与上面一个例子类似,dict是一个字典,收集所有的关键字,传递给函数func。为了提醒Python,参数dict是包裹关键字传递所用的字典,在dict前加**。

包裹传递的关键在于定义函数时,在相应元组或字典前加*或**。

 

解包裹

*和**,也可以在调用的时候使用,即解包裹(unpacking), 下面为例:

def func(a,b,c):
    print a,b,c

args = (1,3,4)
func(*args)

在这个例子中,所谓的解包裹,就是在传递tuple时,让tuple的每一个元素对应一个位置参数。在调用func时使用*,是为了提醒Python:我想要把args拆成分散的三个元素,分别传递给a,b,c。(设想一下在调用func时,args前面没有*会是什么后果?)

 

相应的,也存在对词典的解包裹,使用相同的func定义,然后:

dict = {'a':1,'b':2,'c':3}
func(**dict)

在传递词典dict时,让词典的每个键值对作为一个关键字传递给func。

 

混合

在定义或者调用参数时,参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是,先位置,再关键字,再包裹位置,再包裹关键字,并且根据上面所说的原理细细分辨。

 

注意:请注意定义时和调用时的区分。包裹和解包裹并不是相反操作,是两个相对独立的过程。

 

总结

关键字,默认值,

包裹位置,包裹关键字

解包裹

Python进阶05 循环设计

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

在“循环”一节,我们已经讨论了Python基本的循环语法。这一节,我们将接触更加灵活的循环方式。

 

range()

在Python中,for循环后的in跟随一个序列的话,循环每次使用的序列元素,而不是序列的下标。

之前我们已经使用过range()来控制for循环。现在,我们继续开发range的功能,以实现下标对循环的控制:

S = 'abcdefghijk'
for i in range(0,len(S),2):
    print S[i]

在该例子中,我们利用len()函数和range()函数,用i作为S序列的下标来控制循环。在range函数中,分别定义上限,下限和每次循环的步长。这就和C语言中的for循环相类似了。

 

enumerate()

利用enumerate()函数,可以在每次循环中同时得到下标和元素:

S = 'abcdefghijk'
for (index,char) in enumerate(S):
    print index
    print char

实际上,enumerate()在每次循环中,返回的是一个包含两个元素的定值表(tuple),两个元素分别赋予index和char

 

zip()

如果你多个等长的序列,然后想要每次循环时从各个序列分别取出一个元素,可以利用zip()方便地实现:

ta = [1,2,3]
tb = [9,8,7]
tc = ['a','b','c']
for (a,b,c) in zip(ta,tb,tc):
    print(a,b,c)

每次循环时,从各个序列分别从左到右取出一个元素,合并成一个tuple,然后tuple的元素赋予给a,b,c

zip()函数的功能,就是从多个列表中,依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组,合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能。

 

我们可以分解聚合后的列表,如下:

复制代码
ta = [1,2,3]
tb = [9,8,7]

# cluster
zipped = zip(ta,tb)
print(zipped)

# decompose
na, nb = zip(*zipped)
print(na, nb)
复制代码

 

总结

range()

enumerate()

zip()

Python进阶06 循环对象

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。

循环对象的并不是随着Python的诞生就存在的,但它的发展迅速,特别是Python 3x的时代,循环对象正在成为循环的标准形式。

 

什么是循环对象

循环对象是这样一个对象,它包含有一个next()方法(__next__()方法,在python 3x中), 这个方法的目的是进行到下一个结果,而在结束一系列结果之后,举出StopIteration错误。

当一个循环结构(比如for)调用循环对象时,它就会每次循环的时候调用next()方法,直到StopIteration出现,for循环接收到,就知道循环已经结束,停止调用next()。

假设我们有一个test.txt的文件:

1234
abcd
efg

我们运行一下python命令行:

>>>f = open(‘test.txt’)

>>>f.next()

>>>f.next()

不断输入f.next(),直到最后出现StopIteration

open()返回的实际上是一个循环对象,包含有next()方法。而该next()方法每次返回的就是新的一行的内容,到达文件结尾时举出StopIteration。这样,我们相当于手工进行了循环。

自动进行的话,就是:

for line in open('test.txt'):
    print line

在这里,for结构自动调用next()方法,将该方法的返回值赋予给line。循环知道出现StopIteration的时候结束。

 

相对于序列,用循环对象的好处在于:不用在循环还没有开始的时候,就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样,节省了空间,提高了效率,编程更灵活。

 

迭代器

从技术上来说,循环对象和for循环调用之间还有一个中间层,就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上,常常可以忽略这一层,所以循环对象和迭代器常常相互指代对方。

 

生成器

生成器(generator)的主要目的是构成一个用户自定义的循环对象。

生成器的编写方法和函数定义类似,只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时,会暂停运行生成器,返回yield后面的值。当再次调用生成器的时候,会从刚才暂停的地方继续运行,直到下一个yield。生成器自身又构成一个循环器,每次循环使用一个yield返回的值。

 

下面是一个生成器:

def gen():
    a = 100
    yield a
    a = a*8
    yield a
    yield 1000

该生成器共有三个yield, 如果用作循环器时,会进行三次循环。

for i in gen():
    print i

 

再考虑如下一个生成器:

def gen():
    for i in range(4):
        yield i

它又可以写成生成器表达式(Generator Expression):

G = (x for x in range(4))

生成器表达式是生成器的一种简便的编写方式。读者可进一步查阅。

 

表推导

表推导(list comprehension)是快速生成表的方法。它的语法简单,很有实用价值。

 

假设我们生成表L:

L = []
for x in range(10):
    L.append(x**2)

以上产生了表L,但实际上有快捷的写法,也就是表推导的方式:

L = [x**2 for x in range(10)]

这与生成器表达式类似,只不过用的是中括号。

(表推导的机制实际上是利用循环对象,有兴趣可以查阅。)

 

练习 下面的表推导会生成什么?

xl = [1,3,5]
yl = [9,12,13]
L  = [ x**2 for (x,y) in zip(xl,yl) if y > 10]

 

总结

循环对象

生成器

表推导

Python进阶07 函数对象

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

秉承着一切皆对象的理念,我们再次回头来看函数(function)。函数也是一个对象,具有属性(可以使用dir()查询)。作为对象,它还可以赋值给其它对象名,或者作为参数传递。

 

lambda函数

在展开之前,我们先提一下lambda函数。可以利用lambda函数的语法,定义函数。lambda例子如下:

func = lambda x,y: x + y
print func(3,4)

lambda生成一个函数对象。该函数参数为x,y,返回值为x+y。函数对象赋给func。func的调用与正常函数无异。

 

以上定义可以写成以下形式:

def func(x, y):
    return x + y

 

函数作为参数传递

函数可以作为一个对象,进行参数传递。函数名(比如func)即该对象。比如说:

def test(f, a, b):
    print 'test'
    print f(a, b)

test(func, 3, 5)

test函数的第一个参数f就是一个函数对象。将func传递给f,test中的f()就拥有了func()的功能。

 

我们因此可以提高程序的灵活性。可以使用上面的test函数,带入不同的函数参数。比如:

test((lambda x,y: x**2 + y), 6, 9)

 

map()函数

map()是Python的内置函数。它的第一个参数是一个函数对象。

re = map((lambda x: x+3),[1,3,5,6])

这里,map()有两个参数,一个是lambda所定义的函数对象,一个是包含有多个元素的表。map()的功能是将函数对象依次作用于表的每一个元素,每次作用的结果储存于返回的表re中。map通过读入的函数(这里是lambda函数)来操作数据(这里“数据”是表中的每一个元素,“操作”是对每个数据加3)。

在Python 3.X中,map()的返回值是一个循环对象。可以利用list()函数,将该循环对象转换成表。

 

如果作为参数的函数对象有多个参数,可使用下面的方式,向map()传递函数参数的多个参数:

re = map((lambda x,y: x+y),[1,2,3],[6,7,9])

map()将每次从两个表中分别取出一个元素,带入lambda所定义的函数。

 

filter()函数

filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True,则该次的元素被储存于返回的表中。filter通过读入的函数来筛选数据。同样,在Python 3.X中,filter返回的不是表,而是循环对象。

 

filter函数的使用如下例:

复制代码
def func(a):
    if a > 100:
        return True
    else:
        return False

print filter(func,[10,56,101,500])
复制代码

 

reduce()函数

reduce函数的第一个参数也是函数,但有一个要求,就是这个函数自身能接收两个参数。reduce可以累进地将函数作用于各个参数。如下例:

print reduce((lambda x,y: x+y),[1,2,5,7,9])

reduce的第一个参数是lambda函数,它接收两个参数x,y, 返回x+y。

reduce将表中的前两个元素(1和2)传递给lambda函数,得到3。该返回值(3)将作为lambda函数的第一个参数,而表中的下一个元素(5)作为lambda函数的第二个参数,进行下一次的对lambda函数的调用,得到8。依次调用lambda函数,每次lambda函数的第一个参数是上一次运算结果,而第二个参数为表中的下一个元素,直到表中没有剩余元素。

上面例子,相当于(((1+2)+5)+7)+9

 

根据mmufhy的提醒: reduce()函数在3.0里面不能直接用的,它被定义在了functools包里面,需要引入包,见评论区。

 

总结

函数是一个对象

用lambda定义函数

map()

filter()

reduce()

Python进阶08 异常处理

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

本文特别感谢kylinfish的纠正,相关讨论见留言区。

 

异常处理

在项目开发中,异常处理是不可或缺的。异常处理帮助人们debug,通过更加丰富的信息,让人们更容易找到bug的所在。异常处理还可以提高程序的容错性。

我们之前在讲循环对象的时候,曾提到一个StopIteration的异常,该异常是在循环对象穷尽所有元素时的报错。

我们以它为例,来说明基本的异常处理。

一个包含异常的程序:

re = iter(range(5))

for i in range(100):
    print re.next()

print 'HaHaHaHa'

首先,我们定义了一个循环对象re,该循环对象将进行5次循环,每次使用序列的一个元素。

在随后的for循环中,我们手工调用next()函数。当循环进行到第6次的时候,re.next()不会再返回元素,而是抛出(raise)StopIteration的异常。整个程序将会中断。

 

我们可以修改以上异常程序,直到完美的没有bug。但另一方面,如果我们在写程序的时候,知道这里可能犯错以及可能的犯错类型,我们可以针对该异常类型定义好”应急预案“。

复制代码
re = iter(range(5))

try:
    for i in range(100):
        print re.next()
except StopIteration:
    print 'here is end ',i

print 'HaHaHaHa'
复制代码

在try程序段中,我们放入容易犯错的部分。我们可以跟上except,来说明如果在try部分的语句发生StopIteration时,程序该做的事情。如果没有发生异常,则except部分被跳过。

随后,程序将继续运行,而不是彻底中断。

 

完整的语法结构如下:

复制代码
try:
    ...
except exception1:
    ...
except exception2:
    ...
except:
    ...
else:
    ...
finally:
    ...
复制代码

 

如果try中有异常发生时,将执行异常的归属,执行except。异常层层比较,看是否是exception1, exception2…,直到找到其归属,执行相应的except中的语句。如果except后面没有任何参数,那么表示所有的exception都交给这段程序处理。比如:

try:
    print(a*2)
except TypeError:
    print("TypeError")
except:
    print("Not Type Error & Error noted")

由于a没有定义,所以是NameError。异常最终被except:部分的程序捕捉。

 

如果无法将异常交给合适的对象,异常将继续向上层抛出,直到被捕捉或者造成主程序报错。比如下面的程序

复制代码
def test_func():
    try:
        m = 1/0
    except NameError:
        print("Catch NameError in the sub-function")

try:
    test_func()
except ZeroDivisionError:
    print("Catch error in the main program")
复制代码

子程序的try…except…结构无法处理相应的除以0的错误,所以错误被抛给上层的主程序。

 

如果try中没有异常,那么except部分将跳过,执行else中的语句。

finally是无论是否有异常,最后都要做的一些事情。

流程如下,

try->异常->except->finally

try->无异常->else->finally

 

抛出异常

我们也可以自己写一个抛出异常的例子:

print 'Lalala'
raise StopIteration
print 'Hahaha'

这个例子不具备任何实际意义。只是为了说明raise语句的作用。

StopIteration是一个类。抛出异常时,会自动有一个中间环节,就是生成StopIteration的一个对象。Python实际上抛出的,是这个对象。当然,也可以自行生成对象:

raise StopIteration()

 

总结

try: … except exception: … else: … finally: …
raise exception

Python进阶09 动态类型

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

谢谢TeaEra猫咪cat

 

动态类型(dynamic typing)是Python另一个重要的核心概念。我们之前说过,Python的变量(variable)不需要声明,而在赋值时,变量可以重新赋值为任意值。这些都与动态类型的概念相关。

 

动态类型

在我们接触的对象中,有一类特殊的对象,是用于存储数据的。常见的该类对象包括各种数字,字符串,表,词典。在C语言中,我们称这样一些数据结构为变量。而在Python中,这些是对象。

对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名,只是指向这一对象的引用(reference)。

 

引用和对象分离,是动态类型的核心。引用可以随时指向一个新的对象:

a = 3
a = 'at'

第一个语句中,3是储存在内存中的一个整数对象。通过赋值,引用a指向对象3。

第二个语句中,内存中建立对象‘at’,是一个字符串(string)。引用a指向了’at’。此时,对象3不再有引用指向它。Python会自动将没有引用指向的对象销毁(destruct),释放相应内存。

(对于小的整数和短字符串,Python会缓存这些对象,而不是频繁的建立和销毁。)

 

a = 5
b = a
a = a + 2

再看这个例子。通过前两个句子,我们让a,b指向同一个整数对象5(b = a的含义是让引用b指向引用a所指的那一个对象)。但第三个句子实际上对引用a重新赋值,让a指向一个新的对象7。此时a,b分别指向不同的对象。我们看到,即使是多个引用指向同一个对象,如果一个引用值发生变化,那么实际上是让这个引用指向一个新的引用,并不影响其他的引用的指向。从效果上看,就是各个引用各自独立,互不影响。

 

其它数据对象也是如此:

L1 = [1,2,3]
L2 = L1
L1 = 1

 

但注意以下情况

L1 = [1,2,3]
L2 = L1
L1[0] = 10
print L2

在该情况下,我们不再对L1这一引用赋值,而是对L1所指向的表的元素赋值。结果是,L2也同时发生变化。

原因何在呢?因为L1,L2的指向没有发生变化,依然指向那个表。表实际上是包含了多个引用的对象(每个引用是一个元素,比如L1[0],L1[1]…, 每个引用指向一个对象,比如1,2,3), 。而L1[0] = 10这一赋值操作,并不是改变L1的指向,而是对L1[0], 也就是表对象的一部份(一个元素),进行操作,所以所有指向该对象的引用都受到影响。

(与之形成对比的是,我们之前的赋值操作都没有对对象自身发生作用,只是改变引用指向。)

 

列表可以通过引用其元素,改变对象自身(in-place change)。这种对象类型,称为可变数据对象(mutable object),词典也是这样的数据类型。

而像之前的数字和字符串,不能改变对象本身,只能改变引用的指向,称为不可变数据对象(immutable object)。

我们之前学的元组(tuple),尽管可以调用引用元素,但不可以赋值,因此不能改变对象自身,所以也算是immutable object.

 

从动态类型看函数的参数传递

函数的参数传递,本质上传递的是引用。比如说:

复制代码
def f(x):
    x = 100
    print x

a = 1
f(a)
print a
复制代码

参数x是一个新的引用,指向a所指的对象。如果参数是不可变(immutable)的对象,a和x引用之间相互独立。对参数x的操作不会影响引用a。这样的传递类似于C语言中的值传递。

 

如果传递的是可变(mutable)的对象,那么改变函数参数,有可能改变原对象。所有指向原对象的引用都会受影响,编程的时候要对此问题留心。比如说:

复制代码
def f(x):
    x[0] = 100
    print x

a = [1,2,3]
f(a)
print a
复制代码

 

动态类型是Python的核心机制之一。可以在应用中慢慢熟悉。

 

总结

引用和对象的分离,对象是内存中储存数据的实体,引用指向对象。

可变对象,不可变对象

函数值传递

发表在 python | 标签为 | 留下评论

python-基础

Python基础01 Hello World!

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

简单的‘Hello World!’

 

Python命令行

假设你已经安装好了Python, 那么在Linux命令行输入:

$python

将直接进入python。然后在命令行提示符>>>后面输入:

>>>print(‘Hello World!’)

可以看到,随后在屏幕上输出:

Hello World!

print是一个常用函数,其功能就是输出括号中得字符串。

(在Python 2.x中,print还可以是一个关键字,可写成print ‘Hello World!’,但这在3.x中行不通 )

 

写一段小程序

另一个使用Python的方法,是写一个Python程序。用文本编辑器写一个.py结尾的文件,比如说hello.py

hello.py中写入如下,并保存:

print('Hello World!')

退出文本编辑器,然后在命令行输入:

$python hello.py

来运行hello.py。可以看到Python随后输出

Hello World!

 

脚本

我们还可以把Python程序hello.py改成一个可执行的脚本,直接执行:

#!/usr/bin/env python
print('Hello World!')

 

需要修改上面程序的权限为可执行:

chmod 755 hello.py

 

然后再命令行中,输入

./hello.py

就可以直接运行了

 

总结

print

命令行模式: 运行Python,在命令行输入命令并执行。

程序模式: 写一段Python程序并运行。

Python基础02 基本数据类型

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

简单的数据类型以及赋值

 

变量不需要声明

Python的变量不需要声明,你可以直接输入:

>>>a = 10

那么你的内存里就有了一个变量a, 它的值是10,它的类型是integer (整数)。 在此之前你不需要做什么特别的声明,而数据类型是Python自动决定的。

>>>print a

>>>print type(a)

那么会有如下输出:

10
<type 'int'>

 

这里,我们学到一个内置函数type(), 用以查询变量的类型。

 

回收变量名

如果你想让a存储不同的数据,你不需要删除原有变量就可以直接赋值。

>>>a = 1.3

>>>print a,type(a)

会有如下输出

 

1.3 <type 'float'>

 

我们看到print的另一个用法,也就是print后跟多个输出,以逗号分隔。

 

基本数据类型

a=10         # int 整数

a=1.3        # float 浮点数

a=True       # 真值 (True/False)

a=’Hello!’   # 字符串

以上是最常用的数据类型,对于字符串来说,也可以用双引号。

(此外还有分数,字符,复数等其他数据类型,有兴趣的可以学习一下)

 

总结

变量不需要声明,不需要删除,可以直接回收适用。

type(): 查询数据类型

整数,浮点数,真值,字符串

Python基础03 序列

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

谢谢thunder424纠错

 

sequence 序列

sequence(序列)是一组有顺序的元素的集合

(严格的说,是对象的集合,但鉴于我们还没有引入“对象”概念,暂时说元素)

 

序列可以包含一个或多个元素,也可以没有任何元素。

我们之前所说的基本数据类型,都可以作为序列的元素。元素还可以是另一个序列,以及我们以后要介绍的其他对象。

 

序列有两种:tuple(定值表; 也有翻译为元组) 和 list (表)

>>>s1 = (2, 1.3, ‘love’, 5.6, 9, 12, False)         # s1是一个tuple

>>>s2 = [True, 5, ‘smile’]                          # s2是一个list

>>>print s1,type(s1)

>>>print s2,type(s2)

tuple和list的主要区别在于,一旦建立,tuple的各个元素不可再变更,而list的各个元素可以再变更。

一个序列作为另一个序列的元素

>>>s3 = [1,[3,4,5]]

空序列

>>>s4 = []

 

元素的引用

序列元素的下标从0开始:

>>>print s1[0]

>>>print s2[2]

>>>print s3[1][2]

由于list的元素可变更,你可以对list的某个元素赋值:

>>>s2[1] = 3.0

>>>print s2

如果你对tuple做这样的操作,会得到错误提示。

所以,可以看到,序列的引用通过s[<int>]实现, int为下标

 

其他引用方式

范围引用: 基本样式[下限:上限:步长]

>>>print s1[:5]             # 从开始到下标4 (下标5的元素 不包括在内)

>>>print s1[2:]             # 从下标2到最后

>>>print s1[0:5:2]          # 从下标0到下标4 (下标5不包括在内),每隔2取一个元素 (下标为0,2,4的元素)

>>>print s1[2:0:-1]         # 从下标2到下标1

从上面可以看到,在范围引用的时候,如果写明上限,那么这个上限本身不包括在内。

尾部元素引用

>>>print s1[-1]             # 序列最后一个元素

>>>print s1[-3]             # 序列倒数第三个元素

同样,如果s1[0:-1], 那么最后一个元素不会被引用 (再一次,不包括上限元素本身)

 

字符串是元组

字符串是一种特殊的元素,因此可以执行元组的相关操作。

>>>str = ‘abcdef’

>>>print str[2:4]

 

总结

tuple元素不可变,list元素可变

序列的引用 s[2], s[1:8:2]

字符串是一种tuple

Python基础04 运算

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

Python的运算符和其他语言类似

(我们暂时只了解这些运算符的基本用法,方便我们展开后面的内容,高级应用暂时不介绍)

 

数学运算

>>>print 1+9        # 加法

>>>print 1.3-4      # 减法

>>>print 3*5        # 乘法

>>>print 4.5/1.5    # 除法

>>>print 3**2       # 乘方

>>>print 10%3       # 求余数

 

判断

判断是真还是假,返回True/False

>>>print 5==6               # =, 相等

>>>print 8.0!=8.0           # !=, 不等

>>>print 3<3, 3<=3          # <, 小于; <=, 小于等于

>>>print 4>5, 4>=0          # >, 大于; >=, 大于等于

>>>print 5 in [1,3,5]       # 5是list [1,3,5]的一个元素

(还有is, is not等, 暂时不深入)

 

逻辑运算

True/False之间的运算

>>>print True and True, True and False      # and, “与”运算, 两者都为真才是真

>>>print True or False                      # or, “或”运算, 其中之一为真即为真

>>>print not True                           # not, “非”运算, 取反

可以和上一部分结合做一些练习,比如:

>>>print 5==6 or 3>=3

 

总结

数学 +, -, *, /, **, %

判断 ==, !=, >, >=, <, <=, in

逻辑 and, or, not

Python基础05 缩进和选择

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

缩进

Python最具特色的是用缩进来标明成块的代码。我下面以if选择结构来举例。if后面跟随条件,如果条件成立,则执行归属于if的一个代码块。

 

先看C语言的表达方式(注意,这是C,不是Python!)

if ( i > 0 )
{
    x = 1;
    y = 2;
}

如果i > 0的话,我们将进行括号中所包括的两个赋值操作。括号中包含的就是块操作,它隶属于if。

 

在Python中,同样的目的,这段话是这样的

if i > 0:
    x = 1
    y = 2

在Python中, 去掉了i > 0周围的括号,去除了每个语句句尾的分号,表示块的花括号也消失了。

多出来了if …之后的:(冒号), 还有就是x = 1 和 y =2前面有四个空格的缩进。通过缩进,Python识别出这两个语句是隶属于if。

 

Python这样设计的理由纯粹是为了程序好看。

 

if语句

写一个完整的程序,命名为ifDemo.py。这个程序用于实现if结构。

i = 1
x = 1
if i > 0:
    x = x+1
print x

$python ifDemo.py  # 运行

程序运行到if的时候,条件为True,因此执行x = x+1,。

print x语句没有缩进,那么就是if之外。

 

如果将第一句改成i = -1,那么if遇到假值 (False), x = x+1隶属于if, 这一句跳过。 print x没有缩进,是if之外,不跳过,继续执行。

 

这种以四个空格的缩进来表示隶属关系的书写方式,以后还会看到。强制缩进增强了程序的可读性。

 

复杂一些的if选择:

i = 1
if i > 0:
    print 'positive i'
    i = i + 1
elif i == 0:
    print 'i is 0'
    i = i * 10
else:
    print 'negative i'
    i = i - 1
print 'new i:',i

这里有三个块,分别属于if, elif, else引领。
Python检测条件,如果发现if的条件为假,那么跳过后面紧跟的块,检测下一个elif的条件; 如果还是假,那么执行else块。
通过上面的结构将程序分出三个分支。程序根据条件,只执行三个分支中的一个。

整个if可以放在另一个if语句中,也就是if结构的嵌套使用:

i  = 5
if i > 1:
    print 'i bigger than 1'
    print 'good'
    if i > 2:
        print 'i bigger than 2'
        print 'even better'

if i > 2 后面的块相对于该if缩进了四个空格,以表明其隶属于该if,而不是外层的if。

 

总结

if语句之后的冒号

以四个空格的缩进来表示隶属关系, Python中不能随意缩进

if  <条件1>:

statement

elif <条件2>:

statement

elif <条件3>:

statement

else:

statement

Python基础06 循环

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

循环用于重复执行一些程序块。从上一讲的选择结构,我们已经看到了如何用缩进来表示程序块的隶属关系。循环也会用到类似的写法。

 

for循环

for循环需要预先设定好循环的次数(n),然后执行隶属于for的语句n次。

基本构造是

for 元素 in 序列: 
    statement

 

举例来说,我们编辑一个叫forDemo.py的文件

for a in [3,4.4,'life']:
    print a

这个循环就是每次从表[3,4.4,’life’] 中取出一个元素(回忆:表是一种序列),然后将这个元素赋值给a,之后执行隶属于for的操作(print)。

 

介绍一个新的Python函数range(),来帮助你建立表。

idx = range(5)
print idx

可以看到idx是[0,1,2,3,4]

这个函数的功能是新建一个表。这个表的元素都是整数,从0开始,下一个元素比前一个大1, 直到函数中所写的上限 (不包括该上限本身)

(关于range(),还有丰富用法,有兴趣可以查阅, Python 3中, range()用法有变化,见评论区)

 

举例

for a in range(10):
    print a**2

 

while循环

while的用法是

while 条件:
    statement

while会不停地循环执行隶属于它的语句,直到条件为假(False)

 

举例

while i < 10:
    print i
    i = i + 1

 

中断循环

continue   # 在循环的某一次执行中,如果遇到continue, 那么跳过这一次执行,进行下一次的操作

break      # 停止执行整个循环

for i in range(10):
    if i == 2: 
        continue
    print i

 

当循环执行到i = 2的时候,if条件成立,触发continue, 跳过本次执行(不执行print),继续进行下一次执行(i = 3)。

for i in range(10):
    if i == 2:        
        break
    print i

当循环执行到i = 2的时候,if条件成立,触发break, 整个循环停止。

 

总结

range()

for 元素 in 序列:

while 条件:

continue

break

Python基础07 函数

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

函数最重要的目的是方便我们重复使用相同的一段程序。

将一些操作隶属于一个函数,以后你想实现相同的操作的时候,只用调用函数名就可以,而不需要重复敲所有的语句。

 

函数的定义

首先,我们要定义一个函数, 以说明这个函数的功能。

def square_sum(a,b):
    c = a**2 + b**2
    return c

这个函数的功能是求两个数的平方和。

首先,def,这个关键字通知python:我在定义一个函数。square_sum是函数名。

括号中的a, b是函数的参数,是对函数的输入。参数可以有多个,也可以完全没有(但括号要保留)。

我们已经在循环和选择中见过冒号和缩进来表示的隶属关系。

c = a**2 + b**2        # 这一句是函数内部进行的运算

return c               # 返回c的值,也就是输出的功能。Python的函数允许不返回值,也就是不用return。

return可以返回多个值,以逗号分隔。相当于返回一个tuple(定值表)。

return a,b,c          # 相当于 return (a,b,c)

 

在Python中,当程序执行到return的时候,程序将停止执行函数内余下的语句。return并不是必须的,当没有return, 或者return后面没有返回值时,函数将自动返回None。None是Python中的一个特别的数据类型,用来表示什么都没有,相当于C中的NULL。None多用于关键字参数传递的默认值。

 

函数调用和参数传递

定义过函数后,就可以在后面程序中使用这一函数

print square_sum(3,4)

Python通过位置,知道3对应的是函数定义中的第一个参数a, 4对应第二个参数b,然后把参数传递给函数square_sum。

(Python有丰富的参数传递方式,还有关键字传递、表传递、字典传递等,基础教程将只涉及位置传递)

函数经过运算,返回值25, 这个25被print打印出来。

 

我们再看下面两个例子

a = 1

def change_integer(a):
    a = a + 1
    return a

print change_integer(a)
print a

#===(Python中 "#" 后面跟的内容是注释,不执行 )

b = [1,2,3]

def change_list(b):
    b[0] = b[0] + 1
    return b

print change_list(b)
print b

第一个例子,我们将一个整数变量传递给函数,函数对它进行操作,但原整数变量a不发生变化。

第二个例子,我们将一个表传递给函数,函数进行操作,原来的表b发生变化。

对于基本数据类型的变量,变量传递给函数后,函数会在内存中复制一个新的变量,从而不影响原来的变量。(我们称此为值传递)

但是对于表来说,表传递给函数的是一个指针,指针指向序列在内存中的位置,在函数中对表的操作将在原有内存中进行,从而影响原有变量。 (我们称此为指针传递)

 

总结

def function_name(a,b,c):
    statement
    return something  # return不是必须的

函数的目的: 提高程序的重复可用性。

return     None

通过位置,传递参数。

基本数据类型的参数:值传递

表作为参数:指针传递

 

练习:

写一个判断闰年的函数,参数为年、月、日。若是是闰年,返回True

Python基础08 面向对象的基本概念

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

谢谢逆水寒龙,topmad和Liqing纠错

 

Python使用类(class)和对象(object),进行面向对象(object-oriented programming,简称OOP)的编程。

面向对象的最主要目的是提高程序的重复使用性。我们这么早切入面向对象编程的原因是,Python的整个概念是基于对象的。了解OOP是进一步学习Python的关键。

下面是对面向对象的一种理解,基于分类。

 

相近对象,归为类

在人类认知中,会根据属性相近把东西归类,并且给类别命名。比如说,鸟类的共同属性是有羽毛,通过产卵生育后代。任何一只特别的鸟都在鸟类的原型基础上的。

面向对象就是模拟了以上人类认知过程。在Python语言,为了听起来酷,我们把上面说的“东西”称为对象(object)。

 

先定义鸟类

class Bird(object):
    have_feather = True
    way_of_reproduction  = 'egg'

我们定义了一个类别(class),就是鸟(Bird)。在隶属于这个类比的语句块中,我们定义了两个变量,一个是有羽毛(have_feather),一个是生殖方式(way_of_reproduction),这两个变量对应我们刚才说的属性(attribute)。我们暂时先不说明括号以及其中的内容,记为问题1。

 

假设我养了一只小鸡,叫summer。它是个对象,且属于鸟类。使用前面定义的类:

summer = Bird()
print summer.way_of_reproduction

通过第一句创建对象,并说明summer是类别鸟中的一个对象,summer就有了鸟的类属性,对属性的引用是通过 对象.属性(object.attribute) 的形式实现的。

 

可怜的summer,你就是个有毛产的蛋货,好不精致。

 

动作

日常认知中,我们在通过属性识别类别的时候,有时根据这个东西能做什么事情来区分类别。比如说,鸟会移动。这样,鸟就和房屋的类别区分开了。这些动作会带来一定的结果,比如移动导致位置的变化。

这样的一些“行为”属性为方法(method)。Python中通过在类的内部定义函数,来说明方法。

class Bird(object):
    have_feather = True
    way_of_reproduction = 'egg'
    def move(self, dx, dy):
        position = [0,0]
        position[0] = position[0] + dx
        position[1] = position[1] + dy
        return position

summer = Bird()
print 'after move:',summer.move(5,8)

我们重新定义了鸟这个类别。鸟新增一个方法属性,就是表示移动的方法move。(我承认这个方法很傻,你可以在看过下一讲之后定义个有趣些的方法)

(它的参数中有一个self,它是为了方便我们引用对象自身。方法的第一个参数必须是self,无论是否用到。有关self的内容会在下一讲展开)

 

另外两个参数,dx, dy表示在x、y两个方向移动的距离。move方法会最终返回运算过的position。

在最后调用move方法的时候,我们只传递了dx和dy两个参数,不需要传递self参数(因为self只是为了内部使用)。

 

我的summer可以跑了。

 

子类

类别本身还可以进一步细分成子类

 

比如说,鸟类可以进一步分成鸡,大雁,黄鹂。

在OOP中,我们通过继承(inheritance)来表达上述概念。

class Chicken(Bird):
    way_of_move = 'walk'
    possible_in_KFC = True

class Oriole(Bird):
    way_of_move = 'fly'
    possible_in_KFC = False

summer = Chicken()
print summer.have_feather
print summer.move(5,8)

新定义的鸡(Chicken)类的,增加了两个属性:移动方式(way_of_move),可能在KFC找到(possible_in_KFC)

在类定义时,括号里为了Bird。这说明,Chicken是属于鸟类(Bird)的一个子类,即Chicken继承自Bird。自然而然,Bird就是Chicken的父类。Chicken将享有Bird的所有属性。尽管我只声明了summer是鸡类,它通过继承享有了父类的属性(无论是变量属性have_feather还是方法属性move)

 

新定义的黄鹂(Oriole)类,同样继承自鸟类。在创建一个黄鹂对象时,该对象自动拥有鸟类的属性。

 

通过继承制度,我们可以减少程序中的重复信息和重复语句。如果我们分别定义两个类,而不继承自鸟类,就必须把鸟类的属性分别输入到鸡类和黄鹂类的定义中。整个过程会变得繁琐,因此,面向对象提高了程序的可重复使用性。

(回到问题1, 括号中的object,当括号中为object时,说明这个类没有父类(到头了))

 

将各种各样的东西分类,从而了解世界,从人类祖先开始,我们就在练习了这个认知过程,面向对象是符合人类思维习惯的。所谓面向过程,也就是执行完一个语句再执行下一个,更多的是机器思维。通过面向对象的编程,我们可以更方便的表达思维中的复杂想法。

 

总结

将东西根据属性归类 ( 将object归为class )

方法是一种属性,表示动作

用继承来说明父类-子类关系。子类自动具有父类的所有属性。

self代表了根据类定义而创建的对象。

 

建立对一个对象: 对象名 = 类名()

引用对象的属性: object.attribute

Python基础09 面向对象的进一步拓展

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

我们熟悉了对象和类的基本概念。我们将进一步拓展,以便能实际运用对象和类。

调用类的其它信息

上一讲中提到,在定义方法时,必须有self这一参数。这个参数表示某个对象。对象拥有类的所有性质,那么我们可以通过self,调用类属性。

class Human(object):
    laugh = 'hahahaha'
    def show_laugh(self):
        print self.laugh
    def laugh_100th(self):
        for i in range(100):
            self.show_laugh()

li_lei = Human()          
li_lei.laugh_100th()

这里有一个类属性laugh。在方法show_laugh()中,通过self.laugh,调用了该属性的值。

还可以用相同的方式调用其它方法。方法show_laugh(),在方法laugh_100th中()被调用。

通过对象可以修改类属性值。但这是危险的。类属性被所有同一类及其子类的对象共享。类属性值的改变会影响所有的对象。

 

__init__()方法

__init__()是一个特殊方法(special method)。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有两个下划线。

如果你在类中定义了__init__()这个方法,创建对象时,Python会自动调用这个方法。这个过程也叫初始化。

class happyBird(Bird):
    def __init__(self,more_words):
        print 'We are happy birds.',more_words

summer = happyBird('Happy,Happy!')

这里继承了Bird类,它的定义见上一讲。

 

屏幕上打印:

We are happy birds.Happy,Happy!

我们看到,尽管我们只是创建了summer对象,但__init__()方法被自动调用了。最后一行的语句(summer = happyBird…)先创建了对象,然后执行:

summer.__init__(more_words)

‘Happy,Happy!’ 被传递给了__init__()的参数more_words

 

对象的性质

我们讲到了许多属性,但这些属性是类的属性。所有属于该类的对象会共享这些属性。比如说,鸟都有羽毛,鸡都不会飞。

在一些情况下,我们定义对象的性质,用于记录该对象的特别信息。比如说,人这个类。性别是某个人的一个性质,不是所有的人类都是男,或者都是女。这个性质的值随着对象的不同而不同。李雷是人类的一个对象,性别是男;韩美美也是人类的一个对象,性别是女。

 

当定义类的方法时,必须要传递一个self的参数。这个参数指代的就是类的一个对象。我们可以通过操纵self,来修改某个对象的性质。比如用类来新建一个对象,即下面例子中的li_lei, 那么li_lei就被self表示。我们通过赋值给self.attribute,给li_lei这一对象增加一些性质,比如说性别的男女。self会传递给各个方法。在方法内部,可以通过引用self.attribute,查询或修改对象的性质。

这样,在类属性的之外,又给每个对象增添了各自特色的性质,从而能描述多样的世界。

class Human(object):
    def __init__(self, input_gender):
        self.gender = input_gender
    def printGender(self):
        print self.gender

li_lei = Human('male') # 这里,'male'作为参数传递给__init__()方法的input_gender变量。
print li_lei.gender
li_lei.printGender()

在初始化中,将参数input_gender,赋值给对象的性质,即self.gender。

li_lei拥有了对象性质gender。gender不是一个类属性。Python在建立了li_lei这一对象之后,使用li_lei.gender这一对象性质,专门储存属于对象li_lei的特有信息。

对象的性质也可以被其它方法调用,调用方法与类属性的调用相似,正如在printGender()方法中的调用。

总结

通过self调用类属性

__init__(): 在建立对象时自动执行

类属性和对象的性质的区别

Python基础10 反过头来看看

作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!

 

从最初的“Hello World”,走到面向对象。该回过头来看看,教程中是否遗漏了什么。

我们之前提到一句话,”Everything is Object”. 那么我们就深入体验一下这句话。

 

需要先要介绍两个内置函数,dir()和help()

dir()用来查询一个类或者对象所有属性。你可以尝试一下

>>>print dir(list)

help()用来查询的说明文档。你可以尝试一下

>>>print help(list)

(list是Python内置的一个类,对应于我们之前讲解过的列表)

 

list是一个类

在上面以及看到,表是Python已经定义好的一个类。当我们新建一个表时,比如:

>>>nl = [1,2,5,3,5]

实际上,nl是类list的一个对象。

 

实验一些list的方法:

>>>print nl.count(5)       # 计数,看总共有多少个5

>>>print nl.index(3)       # 查询 nl 的第一个3的下标

>>>nl.append(6)            # 在 nl 的最后增添一个新元素6

>>>nl.sort()               # 对nl的元素排序

>>>print nl.pop()          # 从nl中去除最后一个元素,并将该元素返回。

>>>nl.remove(2)            # 从nl中去除第一个2

>>>nl.insert(0,9)          # 在下标为0的位置插入9

总之,list是一个类。每个列表都属于该类。

Python补充中有list常用方法的附录。

 

运算符是特殊方法

使用dir(list)的时候,能看到一个属性,是__add__()。从形式上看是特殊方法(下划线,下划线)。它特殊在哪呢?

这个方法定义了”+”运算符对于list对象的意义,两个list的对象相加时,会进行的操作。

>>>print [1,2,3] + [5,6,9]

 

运算符,比如+, -, >, <, 以及下标引用[start:end]等等,从根本上都是定义在类内部的方法。

 

尝试一下

>>>print [1,2,3] – [3,4]

会有错误信息,说明该运算符“-”没有定义。现在我们继承list类,添加对”-“的定义

class superList(list):
    def __sub__(self, b):
        a = self[:]     # 这里,self是supeList的对象。由于superList继承于list,它可以利用和list[:]相同的引用方法来表示整个对象。
        b = b[:]        
        while len(b) > 0:
            element_b = b.pop()
            if element_b in a:
                a.remove(element_b)
        return a

print superList([1,2,3]) - superList([3,4])

内置函数len()用来返回list所包含的元素的总数。内置函数__sub__()定义了“-”的操作:从第一个表中去掉第二个表中出现的元素。如果__sub__()已经在父类中定义,你又在子类中定义了,那么子类的对象会参考子类的定义,而不会载入父类的定义。任何其他的属性也是这样。

(教程最后也会给出一个特殊方法的清单)

定义运算符对于复杂的对象非常有用。举例来说,人类有多个属性,比如姓名,年龄和身高。我们可以把人类的比较(>, <, =)定义成只看年龄。这样就可以根据自己的目的,将原本不存在的运算增加在对象上了。

 

下一步

希望你已经对Python有了一个基本了解。你可能跃跃欲试,要写一些程序练习一下。这会对你很有好处。

但是,Python的强大很大一部分原因在于,它提供有很多已经写好的,可以现成用的对象。我们已经看到了内置的比如说list,还有tuple等等。它们用起来很方便。在Python的标准库里,还有大量可以用于操作系统互动,Internet开发,多线程,文本处理的对象。而在所有的这些的这些的基础上,又有很多外部的库包,定义了更丰富的对象,比如numpy, tkinter, django等用于科学计算,GUI开发,web开发的库,定义了各种各样的对象。对于一般用户来说,使用这些库,要比自己去从头开始容易得多。我们要开始攀登巨人的肩膀了。

 

谢谢你的关注,

欢迎来到Python的世界。

 

总结

len() dir() help()

数据结构list(列表)是一个类。

运算符是方法

发表在 python | 标签为 | 留下评论

pip安装使用详解

from:pip安装使用详解

pip类似RedHat里面的yum,安装Python包非常方便。本节详细介绍pip的安装、以及使用方法。

1、pip下载安装

1.1 pip下载

1.2 pip安装

2. pip使用详解

2.1 pip安装包

2.2 pip查看已安装的包

2.3 pip检查哪些包需要更新

2.4 pip升级包

2.5 pip卸载包

3. pip使用实例

3.1 安装redis

3.2 卸载redis

3.3 查看待更新包

4. 常见错误

4.1 ImportError No module named setuptools
请参考《ImportError No module named setuptools解决

5. pip参数解释

6. 结束

安装使用一目了然,太简单了。

发表在 python | 标签为 | 留下评论

python-note

1、How would I build python myself from source code on Ubuntu?

1).At a shell prompt (in a terminal), run
sudo apt-get install build-essential
This will fetch all the common packages you need to build anything (e.g. the compiler etc.).
2).Then run
sudo apt-get build-dep python2.7
This will fetch all the libraries you need to build python.
3).Then download the source code for python and decompress it into a directory.
4).go there and run
./configure –prefix=/path/where/you/want/python/installed
5).Then make and then make install to get it built and installed:
make && make install

2、Upgrading Python (or any package)
$ sudo apt-get update
$ sudo apt-get upgrade python

发表在 python | 标签为 | 留下评论

eclipse-note

1、eclipse不同workspace共用同一设置:
See:https://stackoverflow.com/questions/2078476/how-to-share-eclipse-configuration-over-different-workspaces
1).Go to ${old_workspace}/.metadata/.plugins/org.eclipse.core.runtime/.settings
2).Copy everything under the above directory to ${new_workspace}/.metadata/.plugins/org.eclipse.core.runtime/.settings
This is going to make sure that the ${new_workspace} is having the same configuration as the ${old_workspace}

发表在 eclipse, java | 标签为 | 留下评论

win64下mongo使用

1、将mongdb安装为系统服务
sc create MongoDB binPath= "D:\MongoDB\bin\mongod.exe --service --dbpath D:\MongoDB\data --logpath=D:\MongoDB\logs\mongodb.log  --logappend"
也可以指定配置文件
sc create mongodb64 binPath= “D:/mongodb/bin/mongod.exe –service –config=D:/mongodb/conf/mongo.conf”

解压安装包到D:\MongoDB
建立数据库目录 D:\MongoDB\data
建立日志目录 D:\MongoDB\logs
建立配置文件 D:\MongoDB\conf\mongodb.conf

dbpath=D:\MongoDB\data #数据库路径
logpath=D:\MongoDB\logs\mongodb.log #日志输出文件路径
logappend=true #错误日志采用追加模式,配置这个选项后mongodb的日志会追加到现有的日志文件,而不是从新创建一个新文件
journal=true #启用日志文件,默认启用
quiet=true #这个选项可以过滤掉一些无用的日志信息,若需要调试使用请设置为false
port=27017 #端口号 默认为27017
auth=true  #启用登录认证
rest=true  #启用web用户界面,端口号比服务端口号大1000,此时为28017

这里仅指定了几个常用项,更多详细配置请参考官方文档 http://docs.mongodb.org/manual/reference/configuration-options/

 

发表在 mongo | 标签为 | 留下评论

NoSQL简介

from:NoSQL 简介

NoSQL(NoSQL = Not Only SQL ),意即”不仅仅是SQL”。

在现代的计算系统上每天网络上都会产生庞大的数据量。

这些数据有很大一部分是由关系数据库管理系统(RDMBSs)来处理。 1970年 E.F.Codd’s提出的关系模型的论文 “A relational model of data for large shared data banks”,这使得数据建模和应用程序编程更加简单。

通过应用实践证明,关系模型是非常适合于客户服务器编程,远远超出预期的利益,今天它是结构化数据存储在网络和商务应用的主导技术。

NoSQL 是一项全新的数据库革命性运动,早期就有人提出,发展至2009年趋势越发高涨。NoSQL的拥护者们提倡运用非关系型的数据存储,相对于铺天盖地的关系型数据库运用,这一概念无疑是一种全新的思维的注入。

关系型数据库遵循ACID规则

事务在英文中是transaction,和现实世界中的交易很类似,它有如下四个特性:

1、A (Atomicity) 原子性

原子性很容易理解,也就是说事务里的所有操作要么全部做完,要么都不做,事务成功的条件是事务里的所有操作都成功,只要有一个操作失败,整个事务就失败,需要回滚。

比如银行转账,从A账户转100元至B账户,分为两个步骤:1)从A账户取100元;2)存入100元至B账户。这两步要么一起完成,要么一起不完成,如果只完成第一步,第二步失败,钱会莫名其妙少了100元。

2、C (Consistency) 一致性

一致性也比较容易理解,也就是说数据库要一直处于一致的状态,事务的运行不会改变数据库原本的一致性约束。

例如现有完整性约束a+b=10,如果一个事务改变了a,那么必须得改变b,使得事务结束后依然满足a+b=10,否则事务失败。

3、I (Isolation) 独立性

所谓的独立性是指并发的事务之间不会互相影响,如果一个事务要访问的数据正在被另外一个事务修改,只要另外一个事务未提交,它所访问的数据就不受未提交事务的影响。

比如现有有个交易是从A账户转100元至B账户,在这个交易还未完成的情况下,如果此时B查询自己的账户,是看不到新增加的100元的。

4、D (Durability) 持久性

持久性是指一旦事务提交后,它所做的修改将会永久的保存在数据库上,即使出现宕机也不会丢失。

 

分布式系统

分布式系统(distributed system)由多台计算机和通信的软件组件通过计算机网络连接(本地网络或广域网)组成。

分布式系统是建立在网络之上的软件系统。正是因为软件的特性,所以分布式系统具有高度的内聚性和透明性。

因此,网络和分布式系统之间的区别更多的在于高层软件(特别是操作系统),而不是硬件。

分布式系统可以应用在在不同的平台上如:Pc、工作站、局域网和广域网上等。

 

分布式计算的优点

可靠性(容错) :

分布式计算系统中的一个重要的优点是可靠性。一台服务器的系统崩溃并不影响到其余的服务器。

可扩展性:

在分布式计算系统可以根据需要增加更多的机器。

资源共享:

共享数据是必不可少的应用,如银行,预订系统。

灵活性:

由于该系统是非常灵活的,它很容易安装,实施和调试新的服务。

更快的速度:

分布式计算系统可以有多台计算机的计算能力,使得它比其他系统有更快的处理速度。

开放系统:

由于它是开放的系统,本地或者远程都可以访问到该服务。

更高的性能:

相较于集中式计算机网络集群可以提供更高的性能(及更好的性价比)。

 

分布式计算的缺点

故障排除:

故障排除和诊断问题。

软件:

更少的软件支持是分布式计算系统的主要缺点。

网络:

网络基础设施的问题,包括:传输问题,高负载,信息丢失等。

安全性:

开发系统的特性让分布式计算系统存在着数据的安全性和共享的风险等问题。

 

什么是NoSQL?

NoSQL,指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写,是对不同于传统的关系型数据库的数据库管理系统的统称。

NoSQL用于超大规模数据的存储。(例如谷歌或Facebook每天为他们的用户收集万亿比特的数据)。这些类型的数据存储不需要固定的模式,无需多余操作就可以横向扩展。

为什么使用NoSQL ?

今天我们可以通过第三方平台(如:Google,Facebook等)可以很容易的访问和抓取数据。用户的个人信息,社交网络,地理位置,用户生成的数据和用户操作日志已经成倍的增加。我们如果要对这些用户数据进行挖掘,那SQL数据库已经不适合这些应用了, NoSQL数据库的发展也却能很好的处理这些大的数据。web-data-image

实例

社会化关系网:

Each record: UserID1, UserID2
Separate records: UserID, first_name,last_name, age, gender,…
Task: Find all friends of friends of friends of … friends of a given user.

Wikipedia 页面 :

Large collection of documents
Combination of structured and unstructured data
Task: Retrieve all pages regarding athletics of Summer Olympic before 1950.

 

RDBMS vs NoSQL

RDBMS

高度组织化结构化数据
– 结构化查询语言(SQL) (SQL)

数据和关系都存储在单独的表中。
– 数据操纵语言,数据定义语言

– 严格的一致性
– 基础事务

NoSQL
– 代表着不仅仅是SQL
– 没有声明性查询语言
– 没有预定义的模式
-键 – 值对存储,列存储,文档存储,图形数据库
– 最终一致性,而非ACID属性
– 非结构化和不可预知的数据
– CAP定理
– 高性能,高可用性和可伸缩性bigdata

NoSQL 简史

NoSQL一词最早出现于1998年,是Carlo Strozzi开发的一个轻量、开源、不提供SQL功能的关系数据库。

2009年,Last.fm的Johan Oskarsson发起了一次关于分布式开源数据库的讨论[2],来自Rackspace的Eric Evans再次提出了NoSQL的概念,这时的NoSQL主要指非关系型、分布式、不提供ACID的数据库设计模式。

2009年在亚特兰大举行的”no:sql(east)”讨论会是一个里程碑,其口号是”select fun, profit from real_world where relational=false;”。因此,对NoSQL最普遍的解释是”非关联型的”,强调Key-Value Stores和文档数据库的优点,而不是单纯的反对RDBMS。

 

CAP定理(CAP theorem)

在计算机科学中, CAP定理(CAP theorem), 又被称作 布鲁尔定理(Brewer’s theorem), 它指出对于一个分布式计算系统来说,不可能同时满足以下三点:

  • 一致性(Consistency) (所有节点在同一时间具有相同的数据)
  • 可用性(Availability) (保证每个请求不管成功或者失败都有响应)
  • 分隔容忍(Partition tolerance) (系统中任意信息的丢失或失败不会影响系统的继续运作)

CAP理论的核心是:一个分布式系统不可能同时很好的满足一致性,可用性和分区容错性这三个需求,最多只能同时较好的满足两个。

因此,根据 CAP 原理将 NoSQL 数据库分成了满足 CA 原则、满足 CP 原则和满足 AP 原则三 大类:

  • CA – 单点集群,满足一致性,可用性的系统,通常在可扩展性上不太强大。
  • CP – 满足一致性,分区容忍性的系统,通常性能不是特别高。
  • AP – 满足可用性,分区容忍性的系统,通常可能对一致性要求低一些。cap-theoram-image

 

NoSQL的优点/缺点

优点:

  • – 高可扩展性
  • – 分布式计算
  • – 低成本
  • – 架构的灵活性,半结构化数据
  • – 没有复杂的关系

缺点:

  • – 没有标准化
  • – 有限的查询功能(到目前为止)
  • – 最终一致是不直观的程序

 

BASE

BASE:Basically Available, Soft-state, Eventually Consistent。 由 Eric Brewer 定义。

CAP理论的核心是:一个分布式系统不可能同时很好的满足一致性,可用性和分区容错性这三个需求,最多只能同时较好的满足两个。

BASE是NoSQL数据库通常对可用性及一致性的弱要求原则:

  • Basically Availble –基本可用
  • Soft-state –软状态/柔性事务。
    “Soft state” 可以理解为”无连接”的, 而 “Hard state” 是”面向连接”的
  • Eventual Consistency –最终一致性
    最终一致性, 也是是 ACID 的最终目的。

 

ACID vs BASE

ACID BASE
原子性(Atomicity) 基本可用(Basically Available)
一致性(Consistency) 软状态/柔性事务(Soft state)
隔离性(Isolation) 最终一致性
(Eventual consistency)
持久性
(Durable)

 

NoSQL 数据库分类

类型 部分代表 特点
列存储 Hbase

Cassandra

Hypertable

顾名思义,是按列存储数据的。最大的特点是方便存储结构化和半结构化数据,方便做数据压缩,对针对某一列或者某几列的查询有非常大的IO优势。
文档存储 MongoDB

CouchDB

文档存储一般用类似json的格式存储,存储的内容是文档型的。这样也就有有机会对某些字段建立索引,实现关系数据库的某些功能。
key-value存储 Tokyo Cabinet / Tyrant

Berkeley DB

MemcacheDB

Redis

可以通过key快速查询到其value。一般来说,存储不管value的格式,照单全收。(Redis包含了其他功能)
图存储 Neo4J

FlockDB

图形关系的最佳存储。使用传统关系数据库来解决的话性能低下,而且设计使用不方便。
对象存储 db4o

Versant

通过类似面向对象语言的语法操作数据库,通过对象的方式存取数据。
xml数据库 Berkeley DB XML

BaseX

高效的存储XML数据,并支持XML的内部查询语法,比如XQuery,Xpath。

 

谁在使用

现在已经有很多公司使用了 NoSQL:

  • Google
  • Facebook
  • Mozilla
  • Adobe
  • Foursquare
  • LinkedIn
  • Digg
  • McGraw-Hill Education
  • Vermont Public Radio
发表在 nosql | 标签为 | 留下评论