newbie_evolve's Blog

Happy coding

namedtuple()的用法

namedtuple是python中collections模块的一个函数，它的作用是将元组封装成类类型，以python中类的形式方便用户使用。

代码如下所示：

import collections

#Human是重命名的元组(tuple)的新名字，可以将它看做一个工厂类。

Human= collections.namedtuple('Person','name age gender')
print 'Type of Human',type(Human)#结果为<type,'type'>
bob = Human(name = 'bob',age = 30,gender = 'male')
print 'Representation:',bob
jame = Human(name = 'jame',age = 29,gender = 'female')
print 'Field by name:',jame.name
for people in [bob,jame]:
    print "%s is %d years old %s"% people

经过namedtuple的Person有三个元素，分别名为name，age，gender，它们之间使用空格隔开。

可以使用bob.name来访问name属性

namedtuple(typename, field_names)

注意typename可以与所赋值的名称不一致，例如：

Human= collections.namedtuple('Person','name age gender')

python之年 Comments(36) 2013年9月11日 16:42

Eclipse+pydev常用快捷键

多行缩进（减少缩进）：tab/shift+tab

复制行：Ctrl+Alt+方向键'↓'

删除行：Ctrl+d

自动完成/单词补全：Alt+/

注释：Ctrl+/注释

窗口大小：Ctrl+m

上一个/下一个光标的位置：Alt+Left/Right

上一个/下一个成员(成员对象或成员函数)：Ctrl+Shift+Up/Down

在当前行下插入一行：Shift+Enter

上下移动选中的行：Alt+Up/Down

前一个/后一个单词：Ctrl+Right/Left

删除上一个/下一个单词：Ctrl+Delete/Backspace

python之年 Comments(0) 2013年8月29日 18:14

python常用的内建函数

1、abs(x)返回x的绝对值

2、apply(function,args[,keywords])：apply()函数将args参数应用到function上。例如：apply(add，(1,2,3))等价于add(1,2,3)；keywords参数应该是个字典，字典的关键字是字符串。apply(add,("hello",'world'),{'a':1,'b':2})注：'a','b'与def add(a,b)中的形参名a,b两个参数相同

3、buffer(object[,offset[,size]])：如果object对象支持缓存调用接口，buffer()函数为object对象创建一个新缓存。

4、callable(object)，如果object函数是可以调用对象，则返回真True；否则为假Flase

5、chr(i)：返回与ASCII码i相匹配的一个单一字符串。例如：print chr(72)+chr(101)+chr(108)+chr(111)为hello。chr()函数是ord()函数的反函数，ord()函数将字符串转换回ASCII整数码。

6、cmp(x,y)：比较两个对象是否一样或大小。

7、coerce(x,y)返回一个元组，该元组由两个数值型参数组成(x,y)。

8、compile(string,filename,kind)该函数将string编译为代码对象，编译生成的代码对象接下来被exec语句执行，接着利用eval()函数对其进行求值。filename参数应是代码从其中读取的文件名。如果内部生成文件名，filename参数值应是相应的标识符。kind参数指定string参数中所含代码的类别。kind取值为exec对应语句序列，取值为eval对应对简单表达式，取值为single对应简单交互语句。例如：a = compile('print "hello world"','<string>','single');exec(a) ;eval(a)

9、complex(real,[image])该函数返回一个复数。

10、delatrr(object,name)该函数在object对象许可时，删除object对象的name属性，此函数等价于如下语句：del object.attr

11、dir([object])当没有参数时，dir()函数列出当前局部符号表中保存的名字。

12、divmod(a,b)该函数返回一个元组，该元组包含a除以b的商和余数，如下所示：divmod(7,4)为（1,3）

13、eval(expression[,global[,locals]])该函数将expression字符串作为python标准表达式进行分析并求值，返回expression字符串的值，当不可调用其他可选参数时，expression访问调用该函数的程序段的全局和局部对象。要执行混合了语句和表达式的python任意代码，使用exec语句或使用execfile()函数来动态地执行含有任意代码的文件。

14、execfile(file[,global[,locals]])该函数与exec语句等价，不同之处在于：execfile函数执行文件中的语句，而exec语句处理字符串。

15、filter(function,list)该函数根据function参数返回的结果是否为真(True)来过滤list参数中的项，最后返回一个新列表。例如：a = [1,2,3,4,5,6,7,8,9]; b = filter(lambda x:x > 6,a); print b;b = [7,8,9]

16、float(x)该函数将x参数转换为浮点数，其中x可以使字符串，也可以是数字。

17、getattr(object,name[,default])改函数返回object的name属性值，在语法上，以下语句：getattr(x,'myvalue')等价于x.myvalue，如果参数不存在，但给出了default参数的值，则该函数返回default参数值，否则引发AttributeError异常。

18、globals()该函数返回一个表示当前全局符号表的字典。这个字典通常就是当前模块的字典。如果globals()函数在一个函数或方法中被调用，它就返回定义该函数或方法的模块的符号表，而不是调用此函数的模块的符号表。

19、hasattr(object,name)如果object对象具有与name字符串想匹配的属性，hasattr()函数返回真True，否则返回Flase。

20、hash(object)该函数返回关于object对象的整数散列值。如任何两个对象比较起来是等价的，则它们的散列值是一样的。与id（）效果相似？？

21、hex()该函数将一个整数转换为十六进制字符串，该字符串是个有效的python表达式。

22、id()函数返回值为一个整数，是改对象的“标识”，该标识在其对应对象的生命期内，确保是唯一的和恒定不变的。

23、input()该函数与raw_input()等价

24、isinstance(object,class)该函数在object参数是class参数的一个实例是，返回为真。

25、issubclass(class1,class2)如果class1参数是class2参数的子类，issubclass函数返回真。

26、len(）函数返回一序列(字符串、元组或列表)或字典对象的长度。

27、list()该函数返回列表。例如：list('abc')；结果为['a','b','c']

28、locals()该函数返回表示当前局部符号表的字典。

29、long(x)该函数将字符串或数字转换为长整型数，对浮点数的转换遵循与int()相同的规则。

30、map(function,list,...)该函数将function运用到list中的每一项上，并返回新的列表，如下例所示：a = [1,2,3,4];map(lambda x:pow(x,2),a) 为[1,4,9,16]

31、max(s,*,args...+)返回序列s的最大值。当给定一列参数时，该函数返回给定参数的最大参数。

32、oct()该函数将整数转换为八进制字符串。其结果是个有效的python表达式。

33、open(filename[,mode[,bufsize]])该函数通过mode和缓存bufsize类型打开filename标识的文件，此函数返一文件对象。

34、pow(x,y[,z])该函数返回以x为底数以y为指数的幂值。如果给出z，该函数就计算x的y次幂值被z取模的值，即等价于pow(x,y)%z

35、range([start,]stop[,step])

36、reduce(funciton,sequence[,initializer])该函数一次应用function到sequence中的每个元素上，逐渐缩短整个语句直到为一个单一的值。例如：reduce(lambda x,y:x*y,[1,2,3,4])等价于(((1*2)*3)*4)

37、reload()该函数将以前导入过的模块再加载一次。重新加载包括最初导入模块是应用的分析过程和初始化过程。

38、repr()函数返回对象的字符串表示。这与将对象或属性适用单反引号的结果是一致的。

39、round(x[,n])该函数返回浮点型参数x舍入到十进制小数点后n位的值。如：round(1985,-2)为2000.0

40、setattr(object,name,value)该函数将object参数的name属性设置为value参数值。setattr()函数是getattr()函数的反函数。

41、slice([start,]stop[,step])该函数返回一序列的切片对象，该对象表示由range([start,]stop[,step])指定的索引集。例如：range[20][slice(0,5,2)]结果为[0,2,4]

42、str()该函数与repr()函数相似，唯一不同之处在于：此函数的返回值设计为可打印字符串而不是与eval()函数相兼容的字符串。

43、tuple(object)函数返回一个元组，该元组的项与项的顺序与sequence参数完全一样，例如：tuple('abc')为('a','b','c')

44、unichr(i)该函数返回代码是一个整型参数i的unicode字符的unicode字符串。要将unicode字符转换回整数格式，可以使用ord()函数，没有uniord()函数。

45、unicode(string[,encoding[,errors]])该函数利用编码格式解码器将给定的字符串从一种格式解码为另一种格式。编码的任何错误都用errors参数定义的字符串标记。

46、vars([object])该函数返回对应于当前局部符号表的字典。

47、xrange([start,]stop[,step])该函数与xrange()函数一样，唯一的区别是：xrange()函数返回一个xrange()对象。利用xrang()函数节省下来的内存比起用range()函数是相当可观的。

48、zip()函数处理一系列序列，将这些序列返回一个元组列表。其中每个元组包含了给定的每个序列的第n个元素。例如：a = [1,2,3]; b = [4,5,6] ;zip(a,b) = [(1,4),(2,5),(3,6)]

49、执行任意语句：python支持3条指令，这3条指令允许执行一些任意文件或python代码的字符串，这3条指令是exec()语句、execfile()语句和eval()语句

python之年 Comments(0) 2013年8月30日 14:12

Python设计模式之“代理模式”

代理模式：为其他对象提供代理以控制对这个对象的访问。代理模式在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护目标对象的作用。

 

class Interface():#接口类，RealSuject与Proxy都实现接口类中的Request方法

    def Request(self):

        pass


class RealSubject(Interface):

    def Request(self):

        print "I want to buy a flower"  


class Proxy(Interface):#Proxy与RealSubject类相关联，调用其Request()方法，这样客户端只知道Proxy不清楚RealSubject类的对象

    def Request(self):

        self.realsubject = RealSubject()

        self.realsubject.Request()

        

if __name__ == "__main__":

    p = Proxy()

    p.Request()

 

python之年 Comments(0) 2013年8月19日 10:44

Python设计模式之“抽象工厂模式”

抽象工厂模式：所谓的抽象工厂是指一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。

抽象工厂角色、具体工厂角色、抽象产品角色、具体产品角色

http://blog.csdn.net/ipqxiang/article/details/1955677

 

class ProductA():
    def Show(self):
        pass
 
class ProductA1(ProductA):
    def Show(self):
        print "this is ProductA 1"
 
class ProductA2(ProductA):
    def Show(self):
        print "this is ProductA 2"
        
class ProductB():
    def Show(self):
        pass
    
class ProductB1(ProductB):
    def Show(self):
        print "this is ProductB 1"
 
class ProductB2(ProductB):
    def Show(self):
        print "this is ProductB 2"
        
class Factory():
    def CreateProductA(self):
        pass
    def CreateProductB(self):
        pass
 
class ConcreateFactory1(Factory):
    def CreateProductA(self):
        productA = ProductA1()
        return productA
    
    def CreateProductB(self):
        productB = ProductB1()
        return productB
    
class ConcreateFactory2(Factory):
    def CreateProductA(self):
        productA = ProductA2()
        return productA
    
    def CreateProductB(self):
        productB = ProductB2()   
        return productB
 
if __name__ == "__main__":
    pd = ConcreateFactory1()
    p = pd.CreateProductA()
    p.Show()
    
    

 

python之年 Comments(1) 2013年8月16日 14:02

Python设计模式之“单例模式”

有一些类，应该只有一个实例。这个实例似乎应该在程序启动时被创建出来，且只有在程序结束时才被删除。

单例模式没有公开的构造器，即其构造器是私有的

http://blog.csdn.net/ghostfromheaven/article/details/7671853

python真的需要像其他编程语言中的单例模式吗？

答案是：不需要！

因为python有模块，它是python的单例典范。

模块在一个应用程序中只有一份，它本身就是单例的。将你所需要的属性和方法，直接暴露在模块中变成模块的全局变量和方法即可。

Python单例模式的4种实现方法：

第一种实现：实现__new__方法

 

class Singleton(object):
    def __new__(cls,*args,**kw):#重写__new__
        if not hasattr(cls,'_instance'):cls是否含有_instance
            orig = super(Singleton,cls) #super(Singleton,cls)调用父类object的对象
            cls._instance = orig.__new__(cls,*args,**kw) #调用object的__new__方法生成对象，并赋给cls._instance
        return cls._instance
 
class MyClass(Singleton):
    a = 1
    
one = MyClass()
two = MyClass()
two.a = 3
print one.a
###这里的one和two是同一个对象

python中的__new__:创建对象时调用，返回当前对象的一个实例

_init__:创建对象后调用，对当前对象的实例做一些初始化，无返回值

 

class A(object):
    def __init__(self):
        print "in init"
    def __new__(self):
        print "in new"
 
>>>A()
in new
如果重写了__new__而没有 return instance 那么__init__就不起作用。这说明__new__优先于__init__
第二种实现：共享属性，所谓单例就是所用引用具有相同的属性和方法，同一个类的所有实例自然拥有相同的行为（方法）。所有实例共享属性的最简单最直接的方法就是__dict__属性指向同一个字典。
class Borg(object):
    _state = {}
    def __new__(cls,*args,**kw):
        ob = super(Borg,cls).__new__(cls,*args,**kw)
        ob.__dict__ = cls._state
        return ob
    
class MyClass(Borg):
    a = 1
 
one = MyClass()
two = MyClass()
two.a = 3
print one.a
###这里的one和two是不同对象

第三种实现：是方法一的高级版，使用__metaclass__(元类)的高级python用法

第四种实现：是方法一的高级版，使用装饰器

python之年 Comments(0) 2013年8月16日 15:55

Python设计模式之“工厂方法模式”

工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类时哪一个。工厂方法让类把实例化推迟到子类。

工厂方法模式解决了简单工厂模式的问题：简单工厂模式违背开闭原则。

 

class Pizza():#pizza抽象类
    def GetPizza(self):
        pass
    
class VeggiePizza(Pizza):#素食pizza具体类
    def GetPizza(self):
        print "gave me a VeggiePizza"
 
class CheesePizza(Pizza):#奶酪pizza具体类
    def GetPizza(self):
        print "gave me a CheesePizza"
 
class PizzaFactory():#抽象pizza工厂
    def CreatPizza(self):
        pass
    
class VeggiePizzaFactory(PizzaFactory):#具体素食pizza工厂
    def CreatePizza(self):
        tem = VeggiePizza()
        return tem
    
class CheesePizzaFactory(PizzaFactory):#具体奶酪pizza工厂
    def CreatePizza(self):
        tem = CheesePizza()
        return tem
    
if __name__ == "__main__":
    pizzafac = VeggiePizzaFactory() #要向素食pizza工厂订购pizza
    pizza = pizzafac.CreatePizza()  #素食pizza工厂生产pizza
    pizza.GetPizza() #获得pizza信息
    

 

python之年 Comments(0) 2013年8月16日 09:54

python设计模式之“简单工厂模式”

 

class Pizza():#pizza类
    def display(self):
        pass
class CheesePizza(Pizza):#奶酪pizza
    def display(self):
        print "it CheesePizza"
        
class VeggiePizza(Pizza):#素食pizza
    def display(self):
        print "it VeggiePizza"
        
class ClamPizza(Pizza):#海鲜pizza
    def display(self):
        print "it ClamPizza"
class PizzaUndef(Pizza):#未定义的pizza
    def display(self):
        print "undefine operation"
        return None
 
class PizzaFactory():#pizza工厂
    pizz = {}#使用字典
    pizz["ch"] = CheesePizza()
    pizz["ve"] = VeggiePizza()
    pizz["cl"] = ClamPizza()
    def createPizza(self,tem):
        if tem in self.pizz:
            pi = self.pizz[tem]
        else:
            pi =  PizzaUndef()
        return pi
if __name__ =="__main__":
    op = raw_input("Pizza:")
    factory = PizzaFactory()
    cal = factory.createPizza(op)
    cal.display()
简单工厂模式：工厂可根据条件产生不同功能的类。
简单工厂其实并不是一个设计模式，它反而更像一种编码习惯。

python之年 Comments(0) 2013年8月15日 15:06

python设计模式之“装饰者模式”

 

everage:饮料    HouseBlend：混合咖啡  decaf：无咖啡因咖啡 DarkRoast：深度烘焙咖啡 
Milk:牛奶     Soy：豆粉        Whip：搅拌机  CondimentDecorator：调味品装饰者
class beverage():
    def __init__(self):
        pass
    def cost(self):
        pass
    
class HouseBlend(beverage):
    def __init__(self):
        beverage.__init__(self)
    def cost(self):
        return 1.0
    
class decaf(beverage):
    def __init__(self):
        beverage.__init__(self)
    def cost(self):
        return 2.0
    
class DarkRoast(beverage):
    def __init__(self):
        beverage.__init__(self)
    def cost(self):
        return 4.0
   
class CondimentDecorator(beverage):
    def __init__(self,comp):
        beverage.__init__(self)
        self.comp = comp
    def cost(self):
        pass    
    
class Milk(CondimentDecorator):
    def __init__(self,com):
        CondimentDecorator.__init__(self,com)
    def cost(self):
        return 10 + self.comp.cost()
      
class Soy(CondimentDecorator):
    def __init__(self,com):
        CondimentDecorator.__init__(self,com)
    def cost(self):
        return 20 +  self.comp.cost()
    
class Whip(CondimentDecorator):
    def __init__(self,com):
        CondimentDecorator.__init__(self,com)
    def cost(self):
        return 30 +  self.comp.cost()
    
if __name__ =="__main__":
    compont = decaf()
    compont = Milk(compont)
    compont = Soy(compont)
    print compont.cost()
装饰者模式：
一、装饰对象（Decorator）和真实对象（ConcreteDecorator）有相同的接口。如Milk、Soy与decaf
二、装饰（Decorator）对象包含一个真实对象的引用，如decaf的引用:compont
总结：装饰者模式可以动态给一个对象添加一些额外的职责，就增加功能来说，Decorator模式比生成子类更为灵活。

python之年 Comments(0) 2013年8月15日 11:33

python设计模式之“策略模式”

 

class Duck():
    def __init__(self,flyBehavior):
        self.flyBehavior = flyBehavior
    def display(self):
        pass
    
class FlyBehavior():
    def __init__(self):
        pass
    def fly(self):
        pass
 
class FlyWithWings(FlyBehavior):
    def __init__(self):
        FlyBehavior.__init__(self)
    def fly(self):
        print "I can fly with wings"
class FlyNoWay(FlyBehavior):
    def __init__(self):
        FlyBehavior.__init__(self)
    def fly(self):
        print "I have no wings, I can't fly"
 
if __name__ == "__main__":
    duck = Duck(FlyWithWings())
    duck.flyBehavior.fly()
设计原则之一：少用继承，多用组合。
在这里self.flyBehavior就是运用了组合。设计模式应充分考虑变化的元素，并将其封装。策略模式定义了算法族，将它们封装起来，并可以相互替换，此模式让算法的变化独立于使用算法的客户。

 

python之年 Comments(0) 2013年8月15日 10:48