builtin

http://www.pythontab.com/html/2013/hanshu_0216/226.html

bytearray(string, encoding[, errors]) -> bytearray.
chr将数字转成对应的字符，ord是将字符转成对应的数字，bytearray是将字符串中的每个字母都转成对应的数字，显示格式是bytearray(string)，但是其实这个变量就是一个数字的list，可以通过下标取得数据；

在python2.7中bytes就是一个字符串对象，bytearray对象则是一个byte列表，对象的每一位都是对应字符的二进制数据；同时bytearray对象可以有字符串的其他操作，比如find，replace等方法，用到字符串的时候，直接就可以用字符串不用转成bytearray类型用；
>>> set(dir('abc'))-set(dir(bytearray('ab')))
set(['__getslice__', 'format', '__mod__', '_formatter_field_name_split', 'encode', '__rmod__', '__getnewargs__', '_formatter_parser'])
同时可以看到bytearray对象没有format和encode方法；

bytearray([source [, encoding [, errors]]])

中文说明：

bytearray([source [, encoding [, errors]]])返回一个byte数组。Bytearray类型是一个可变的序列，并且序列中的元素的取值范围为 [0 ,255]。

参数source:

如果source为整数，则返回一个长度为source的初始化数组；

如果source为字符串，则按照指定的encoding将字符串转换为字节序列；

如果source为可迭代类型，则元素必须为[0 ,255]中的整数；

如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray.。

版本：在python2.6后新引入，在python3中同样可以使用！

实例演示：

>>> a = bytearray( 3 )

>>> a

bytearray(b '\x00\x00\x00' )

>>> a[ 0 ]

>>> a[ 1 ]

>>> a[ 2 ]

>>> b = bytearray( "abc" )

>>> b

bytearray(b 'abc' )

>>> b[ 0 ]

>>> b[ 1 ]

>>> b[ 2 ]

>>> c = bytearray([ 1 , 2 , 3 ])

>>> c

bytearray(b '\x01\x02\x03' )

>>> c[ 0 ]

>>> c[ 1 ]

>>> c[ 2 ]

>>> d = bytearray( buffer ( "abc" ))

>>> d

bytearray(b 'abc' )

>>> d[ 0 ]

>>> d[ 1 ]  

>>> d[ 2 ]



callable(object)

中文说明：检查对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

注意：类是可调用的，而类的实例实现了__call__()方法才可调用。

版本：该函数在python2.x版本中都可用。但是在python3.0版本中被移除，而在python3.2以后版本中被重新添加。

代码实例：

>>> callable ( 0 )

False

>>> callable ( "mystring" )

False

>>> def add(a, b):

…     return a + b

…

>>> callable (add)

True

>>> class A:

…      def method( self ):

…         return 0

…

>>> callable (A)

True

>>> a = A()

>>> callable (a)

False

>>> class B:

…     def __call__( self ):

…         return 0

…

>>> callable (B)

True

>>> b = B()

>>> callable (b)

True



python classmethod类方法的要点主要有3个：///

1 在python中.类方法 @classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。
 2 普通对象方法至少需要一个self参数，代表类对象实例
 3 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。 对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法, 也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。

#encoding=utf-8
class info( object ):
    @classmethod
    def sayclassmethod( cls ):
        print 'say %s ' % cls
    def saymethod( self ):
        print 'say %s ' % self

test = info()
test . saymethod() ##实例调用方法
test . sayclassmethod() ##实例调用类方法
info . saymethod( test) ##类调用实例方法
info . sayclassmethod() ##类调用类方法

compile(source, filename, mode[, flags[, dont_inherit]])//

中文说明：将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。

参数source：字符串或者AST（Abstract Syntax Trees）对象。

参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。

参数flag和dont_inherit：这两个参数暂不介绍，可选参数。

版本：在python2.3、2.6、2.7、3.2中均有不同，使用时要引起注意，兼容python3

>>> code = "for i in range(0, 10): print i"

>>> cmpcode = compile (code, ' ', ' exec ')

>>> exec cmpcode

0

1

2

3

4

5

6

7

8

9

>>> str = "3 * 4 + 5"

>>> a = compile ( str ,' ',' eval ')

>>> eval (a)

17

//

dir()函数

中文说明：

你可以使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。

当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。

首先，我们来看一下在输入的sys模块上使用dir。我们看到它包含一个庞大的属性列表。

接下来，我们不给dir函数传递参数而使用它——默认地，它返回当前模块的属性列表。注意，输入的模块同样是列表的一部分。

为了观察dir的作用，我们定义一个新的变量a并且给它赋一个值，然后检验dir，我们观察到在列表中增加了以上相同的值。我们使用del语句删除当前模块中的变量/属性，这个变化再一次反映在dir的输出中。

关于del的一点注释——这个语句在运行后被用来 删除 一个变量/名称。在这个例子中，del a，你将无法再使用变量a——它就好像从来没有存在过一样。

/
getattr()
>>>import sys
>>>pt=getattr(sys,'path')

isinstance()的用法：
>>> class a:
    v1=1
   
>>> class b:
    v2=2

>>> class c(a):
    v3=3

>>> x=c()
>>> isinstance(x,c)
True
>>> isinstance(x,a)
True
>>> isinstance(x,b)
False
>>>
///
>>> issubclass(c,a)
True
>>> issubclass(c,b)
False
>>> issubclass(a,c)
False

///
>>> for ii in iter('bcd'):
    print ii

b
c
d

map(function, sequence) ：对sequence中的item依次执行function(item)，见执行结果组成一个List返回：
>>> def cube(x): return x*x*x 
>>> map(cube, range(1, 11)) 
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> def cube(x) : return x + x

>>> mymap=map(abs,[1,2,3,-4])
>>> mymap
[1, 2, 3, 4]
///
next(iter([1,2]))
/

大家也许知道C#中提供了属性Property这个概念，让我们在对私有成员赋值、获取时更加方便，而不用像C++分别定义set*和get*两个函数，在使用时也就像直接使用变量一样。

今天突然发现Python中竟然也提供了如此类似的方法，感到甚为亲切，发上来大家一起讨论一下，有不妥的地方还请多多指教。

假设定义了一个类:C，该类必须继承自object类，有一私有变量__x

1. class C:  
2. 　def __init__(self):  
3. 　　self.__x=None  
4. 　　1.现在介绍第一种使用属性的方法：  
5. 　　在该类中定义三个函数，分别用作赋值、取值和删除变量（此处表达也许不很清晰，请看示例）  
6. 　def getx(self):  
7. 　　return self.__x  
8. 　def setx(self,value):  
9. 　　self.__x=value  
10. 　def delx(self):  
11. 　　del self.__x  

在类中在增加一条语句：x=property(getx,setx,delx,'')，property函数原型为property(fget=None,fset=None,fdel=None,doc=None)，所以根据自己需要定义相应的函数即可。
现在这个类中的x属性便已经定义好了，我们可以先定义一个C的实例c=C()，然后赋值c.x=100，取值y=c.x，删除：del c.x。是不是很简单呢？请看第二种方法

下面看第二种方法（在2.6中新增）
首先定义一个类C：

1. class C:  
2. 　def __init__(self):  
3. 　　self.__x=None  
4. 　　下面就开始定义属性了  
5. 　@property  
6. 　def x(self):  
7. 　　return self.__x  
8. 　@x.setter  
9. 　def x(self,value):  
10. 　　self.__x=value  
11. 　@x.deleter  
12. 　def x(self):  
13. 　　del self.__x  

到此为止就可以像上面一样使用x属性了。
>>> c.x=101
>>> print c.x
101
>>> del c.x
>>> print c.x
None
如果打算设为只读或者只写属性，那就定义一个函数吧，不过同一属性的三个函数名要相同。

//

Python 有办法将任意值转为字符串：将它传入repr() 或str() 函数。

repr()与反引号操作符``做的是完全一样的事情；

repr()返回的是一个对象的"官方"字符串表示（对python比较友好），绝大多数情况下可以通过求值运算（使用内建函数eval()）重新得到该对象。即 obj= eval(repr(obj))，也有情况下，不能够通过eval()得到原来的对象.
>>> ss='hello lily'
>>> str(ss)
'hello lily'
>>> repr(ss)
"'hello lily'"
>>> str(0.1)
'0.1'
>>> repr(0.1)
'0.1'
>>>
///

一、Python的排序

1、reversed()

这个很好理解，reversed英文意思就是：adj. 颠倒的；相反的；（判决等）撤销的

print list(reversed(['dream','a','have','I']))
#['I', 'have', 'a', 'dream']

2、让人糊涂的sort()与sorted()

在Python 中sorted是内建函数(BIF),而sort()是列表类型的内建函数list.sort()。

//
slice( [start,] stop[, step])
返回一个切片对象，它表示的是range(start, stop, step)指定的范围。start和step参数默认为None。切片对象有只读数据属性start，stop和step，它只是返回参数值（或默认）。没有其他明确的功能，但它们的作为数值 Python和其他第三方扩展使用。

1.先说一下iterable，中文意思是迭代器。

Python的帮助文档中对iterable的解释是：iteralbe指的是能够一次返回它的一个成员的对象。iterable主要包括3类：

第一类是所有的序列类型，比如list(列表)、str(字符串)、tuple(元组)。

第二类是一些非序列类型，比如dict(字典)、file(文件)。

第三类是你定义的任何包含__iter__()或__getitem__()方法的类的对象。

2.Python帮助文档中对sorted方法的讲解：

sorted(iterable[,cmp,[,key[,reverse=True]]])

作用：Return a new sorted list from the items in iterable.

          第一个参数是一个iterable，返回值是一个对iterable中元素进行排序后的列表(list)。

可选的参数有三个，cmp、key和reverse。

1)cmp指定一个定制的比较函数，这个函数接收两个参数（iterable的元素），如果第一个参数小于第二个参数，返回一个负数；如果第一个参数等于第二个参数，返回零；如果第一个参数大于第二个参数，返回一个正数。默认值为None。

2)key指定一个接收一个参数的函数，这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None。

3)reverse是一个布尔值。如果设置为True，列表元素将被倒序排列。

通常来说，key和reverse比一个等价的cmp函数处理速度要快。这是因为对于每个列表元素，cmp都会被调用多次，而key和reverse只被调用一次。

3.具体的用法如下：

1)排序基础

一个简单的升序排列很简单-只需要调用sorted()函数即可。 这个函数返回一个新的排序列表。：

>>> sorted([5,2,3,1,4])

[1,2,3,4,5]

你也可以使用list的list.sort()方法。这个方法会修改原始的list（返回值为None）。通常这个方法不如sorted()方便-如果你不需要原始的list，list.sort()方法效率会稍微高一些。

>>> a=[5,2,3,1,4]

>>> a.sort()

>>> a

[1,2,3,4,5]

另一个区别在于list.sort()方法只为list定义。而sorted()函数可以接收任何的iterable。

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}) [1, 2, 3, 4, 5]

2)Key Functions(关键字函数)

从Python2.4开始，list.sort()和sorted()方法都添加了一个key参数来说明一个函数，这个函数在做比较之前会对list中的每个元素进行调用。

例如，这里是一个大小写不敏感的字符串比较：

>>> sorted("This is a test string from Andrew".split(), key=str.lower) ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

key的值应该是一个函数，这个函数接收一个参数并且返回一个用于比较的关键字。这种技术比较快，原因在于对每个输入记录，这个函数只会被调用一次。

对复杂对象的比较通常是使用对象的切片作为关键字。例如：

>>> student_tuples = [         ('john', 'A', 15),         ('jane', 'B', 12),         ('dave', 'B', 10), ]
 >>> sorted(student_tuples, key=lambda student: student[2])   # sort by age [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

同样的技术适用于有named属性的对象。例如：

>>> class Student:         def __init__(self, name, grade, age):
                                         self.name = name
                                         self.grade = grade
                                         self.age = age
                          def __repr__(self):                 
                                         return repr((self.name, self.grade, self.age))  
>>> student_objects = [Student('john', 'A', 15),Student('jane', 'B', 12),Student('dave', 'B', 10), ]
>>> sorted(student_objects, key=lambda student: student.age)   # sort by age [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

3)Operator Module Functions (Operator模块中的函数)

上面的key-function模式很常见，因此Python提供了方便的函数使得祖先函数更简单和快捷。operator module有itemgetter,attrgetter，以及从Python2.6开始的methodcaller函数。

使用这些函数，上面的例子会变得更简单和快捷：

>>> from operator import itemgetter, attrgetter  
>>> sorted(student_tuples, key=itemgetter(2)) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]  
>>> sorted(student_objects, key=attrgetter('age')) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

operator模块支持多级排序。例如先按成绩排序，再按年龄排序：

>>> sorted(student_tuples, key=itemgetter(1,2)) [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]  
>>> sorted(student_objects, key=attrgetter('grade', 'age')) [('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]

4)升序和降序

list.sort()和sorted()都接收一个reverse参数。它是用于降序排序的标志。例如，为了获得学生年龄的降序排序：

>>> sorted(student_tuples, key=itemgetter(2), reverse=True) [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]  >>> sorted(student_objects, key=attrgetter('age'), reverse=True) [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

5)排序稳定性和复杂的排序 从Python2.2开始，排序都保证是稳定的。意思是当多个记录有相同的关键字时，它们原始的排序保留。

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)] 
>>> sorted(data, key=itemgetter(0)) [('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

注意到两个'blue'的记录保留了它们原始的顺序，因此('blue',1)保证在('blue',2)之前。  这个好的特性能让你建立复杂的排序。例如，将学生记录按成绩降序排序、按年两升序排列。先按年龄排序，再按成绩排序。  
>>> s=sorted(student_object,key=attrgettter('age')) # sort on secondary key
 >>> sorted(s,key=attrgetter('grade'),reverse=True) [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

/

sum()的参数是一个list

例如：

sum([1,2,3])

sum(range(1,11))

还有一个比较有意思的用法

a = range(1,11)

b = range(1,10)

c =  sum([item for item in a if item in b])

print c

输出：

45

///

super()的调用参数是约定好的，第一个参数告诉父类调用它的是哪个子类(父类可能有多个子类继承它), 第二个参数告诉父类是哪个具体的实例在调用。这个过程其实没有生成任何新的类实例。

"""

 

[GCC  4.7 . 2 ] on linux2

Type  "help" ,  "copyright" ,  "credits"  or  "license"  for  more information.

>>>  class  A( object ):

...      def  P( self ):

...              print ( "A.P()" )

...              print  self

... 

>>>  class  B(A):

...      def  P( self ):

...              print ( "B.P()" )

...              super (B,  self ).P()

...      def  p( self ):

...              print  self

... 

>>> a  =  A()

>>> a.P()

A.P()

<__main__.A  object  at  0xb744864c >

>>> b  =  B()

>>> b.P()

B.P()

A.P()

<__main__.B  object  at  0xb74488ac >

>>> b.p()

<__main__.B  object  at  0xb74488ac >

>>>

//
type()

在项目中，我们会在每个接口验证客户端传过来的参数类型，如果验证不通过，返回给客户端“参数错误”错误码。

这样做不但便于调试，而且增加健壮性。因为客户端是可以作弊的，不要轻易相信客户端传过来的参数。

验证类型用type函数，非常好用，比如

>>type('foo') == str

True

>>type(2.3) in (int,float)

True

既然有了type()来判断类型，为什么还有isinstance()呢？

一个明显的区别是在判断子类。

type()不会认为子类是一种父类类型。

isinstance()会认为子类是一种父类类型。

千言不如一码。

class Foo( object ):      pass      class Bar(Foo):      pass      print type (Foo()) = = Foo print type (Bar()) = = Foo print isinstance (Bar(),Foo)     class Foo( object ):      pass     class Bar(Foo):      pass     print type (Foo()) = = Foo print type (Bar()) = = Foo print isinstance (Bar(),Foo) 输出 True False True

需要注意的是，旧式类跟新式类的type()结果是不一样的。旧式类都是<type 'instance'>。

class A:      pass      class B:      pass      class C( object ):      pass      print 'old style class' , type (A()) print 'old style class' , type (B()) print 'new style class' , type (C()) print type (A()) = = type (B())     class A:      pass     class B:      pass     class C( object ):      pass     print 'old style class' , type (A()) print 'old style class' , type (B()) print 'new style class' , type (C()) print type (A()) = = type (B()) 输出 old style class < type 'instance' > old style class < type 'instance' > new style class < class '__main__.C' > True

不存在说isinstance比type更好。只有哪个更适合需求。

///
zip()

一、代码引导

首先看这一段代码：

>>> name = ( 'jack' , 'beginman' , 'sony' , 'pcky' ) >>> age = ( 2001 , 2003 , 2005 , 2000 ) >>> for a,n in zip (name,age):      print a,n

输出：

jack 2001

beginman 2003

sony 2005

pcky 2000

再看这一段代码：

all = { "jack" : 2001 , "beginman" : 2003 , "sony" : 2005 , "pcky" : 2000 }   for i in all .keys():       print i, all [i]

 输出：

sony 2005

pcky 2000

jack 2001

beginman 2003

发现它们之间的区别么？

最显而易见的是：第一种简洁、灵活、而且能顺序输入。

二、zip()函数

它是Python的内建函数，(与序列有关的内建函数有：sorted()、reversed()、enumerate()、zip()),其中sorted()和zip()返回一个序列(列表)对象，reversed()、enumerate()返回一个迭代器(类似序列)

>>> type ( sorted (s))   < type 'list' >   >>> type ( zip (s))   < type 'list' >   >>> type ( reversed (s))   < type 'listreverseiterator' >   >>> type ( enumerate (s))   < type 'enumerate' >

那么什么是zip()函数 呢？

我们help(zip)看看：

>>> help(zip)

Help on built-in function zip in module __builtin__:

zip(...)

    zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

   

    Return a list of tuples, where each tuple contains the i-th element

    from each of the argument sequences.  The returned list is truncated

    in length to the length of the shortest argument sequence.

提示：不懂的一定多help

定义：zip([seql, ...])接受一系列可迭代对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。

>>> z1 = [ 1 , 2 , 3 ]   >>> z2 = [ 4 , 5 , 6 ]   >>> result = zip (z1,z2)   >>> result   [( 1 , 4 ), ( 2 , 5 ), ( 3 , 6 )]   >>> z3 = [ 4 , 5 , 6 , 7 ]   >>> result = zip (z1,z3)   >>> result   [( 1 , 4 ), ( 2 , 5 ), ( 3 , 6 )]   >>>

zip()配合*号操作符,可以将已经zip过的列表对象解压

>>> zip(*result)

[(1, 2, 3), (4, 5, 6)]

更近一层的了解：

* 二维矩阵变换（矩阵的行列互换）

比如我们有一个由列表描述的二维矩阵

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

通过python列表推导的方法，我们也能轻易完成这个任务

print [ [row[col] for row in a] for col in range(len(a[0]))]

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

另外一种让人困惑的方法就是利用zip函数：

>>> a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> zip(*a)

[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

>>> map(list,zip(*a))

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

zip函数接受任意多个序列作为参数，将所有序列按相同的索引组合成一个元素是各个序列合并成的tuple的新序列，新的序列的长度以参数中最短的序列为准。另外(*)操作符与zip函数配合可以实现与zip相反的功能，即将合并的序列拆成多个tuple。

①tuple的新序列

>>>>x=[1,2,3],y=['a','b','c']

>>>zip(x,y)

[(1,'a'),(2,'b'),(3,'c')]

②新的序列的长度以参数中最短的序列为准.

>>>>x=[1,2],y=['a','b','c']

>>>zip(x,y)

[(1,'a'),(2,'b')]

③(*)操作符与zip函数配合可以实现与zip相反的功能,即将合并的序列拆成多个tuple。

>>>>x=[1,2,3],y=['a','b','c']

>>>>zip(*zip(x,y))

[(1,2,3),('a','b','c')]

__import()__
    我们知道import语句是用来导入外部模块的，当然还有from...import...也可以，但是其实import实际上是使用builtin函数__import__来工作的。
    在一些程序中，我们可以动态地去调用函数，如果我们知道模块的名称(字符串)的时候，我们可以很方便的使用动态调用。

目录结构：

manager.py

/dbpackage

    models.py

运行manager.py shell（如果用过django的话，应该知道怎么回事）

>>> mod=__import__("dbpackage")
>>> mod
<module 'dbpackage' from 'E:/testProgram/DynamicImport/src/dynamicTest/dbpackage/__init__.pyc'>

这个好理解，导入包dbpackage

>>> mod=__import__("dbpackage.models")
>>> mod
<module 'dbpackage' from 'E:/testProgram/DynamicImport/src/dynamicTest/dbpackage/__init__.pyc'>

这个就不好理解，为什么没导入models？原来要导入models要这样做：

>>> mod=__import__("dbpackage.models",{},{},["models"])
>>> mod
<module 'dbpackage.models' from 'E:/testProgram/DynamicImport/src/dynamicTest/dbpackage/models.pyc'>

这样才可以导入models模块