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()，写成这样之后它就是类的一个实例了。
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
[1, 2, 3, 4]
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
next(iter([1,2]))
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
大家也许知道C#中提供了属性Property这个概念，让我们在对私有成员赋值、获取时更加方便，而不用像C++分别定义set*和get*两个函数，在使用时也就像直接使用变量一样。
今天突然发现Python中竟然也提供了如此类似的方法，感到甚为亲切，发上来大家一起讨论一下，有不妥的地方还请多多指教。
假设定义了一个类:C，该类必须继承自object类，有一私有变量__x
- class C:
- def __init__(self):
- self.__x=None
- 1.现在介绍第一种使用属性的方法：
- 在该类中定义三个函数，分别用作赋值、取值和删除变量（此处表达也许不很清晰，请看示例）
- def getx(self):
- return self.__x
- def setx(self,value):
- self.__x=value
- def delx(self):
- del self.__x
现在这个类中的x属性便已经定义好了，我们可以先定义一个C的实例c=C()，然后赋值c.x=100，取值y=c.x，删除：del c.x。是不是很简单呢？请看第二种方法
下面看第二种方法（在2.6中新增）
首先定义一个类C：
- class C:
- def __init__(self):
- self.__x=None
- 下面就开始定义属性了
- @property
- def x(self):
- return self.__x
- @x.setter
- def x(self,value):
- self.__x=value
- @x.deleter
- def x(self):
- del self.__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和其他第三方扩展使用。
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
>>> 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)] /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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模块