最常见的内置函数是:

print("Hello World!")

数学运算

abs(-5) # 取绝对值，也就是5

round(2.6) # 四舍五入取整，也就是3.0

pow(2, 3) # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5

cmp(2.3, 3.2) # 比较两个数的大小

divmod(9,2) # 返回除法结果和余数

max([1,5,2,9]) # 求最大值

min([9,2,-4,2]) # 求最小值

sum([2,-1,9,12]) # 求和

类型转换

int("5") # 转换为整数 integer

float(2) # 转换为浮点数 float

long("23") # 转换为长整数 long integer

str(2.3) # 转换为字符串 string

complex(3, 9) # 返回复数 3 + 9i

ord("A") # "A"字符对应的数值

chr(65) # 数值65对应的字符

unichr(65) # 数值65对应的unicode字符

bool(0) # 转换为相应的真假值，在Python中，0相当于False

在Python中，下列对象都相当于False：[], (),{},0,
None,0.0,''

bin(56) # 返回一个字符串，表示56的二进制数

hex(56) # 返回一个字符串，表示56的十六进制数

oct(56) # 返回一个字符串，表示56的八进制数

list((1,2,3)) # 转换为表 list

tuple([2,3,4]) # 转换为定值表 tuple

slice(5,2,-1) # 构建下标对象 slice

dict(a=1,b="hello",c=[1,2,3]) # 构建词典 dictionary

序列操作

all([True, 1, "hello!"]) # 是否所有的元素都相当于True值

any(["", 0, False, [], None]) # 是否有任意一个元素相当于True值

sorted([1,5,3]) # 返回正序的序列，也就是[1,3,5]

reversed([1,5,3]) # 返回反序的序列，也就是[3,5,1]

类，对象，属性

# define class
class Me(object):
def test(self):
print "Hello!"
def new_test():
print "New Hello!"
me = Me()

hasattr(me, "test") # 检查me对象是否有test属性

getattr(me, "test") # 返回test属性

setattr(me, "test", new_test) # 将test属性设置为new_test

delattr(me, "test") # 删除test属性

isinstance(me, Me) # me对象是否为Me类生成的对象 (一个instance)

issubclass(Me, object) # Me类是否为object类的子类

编译，执行

repr(me) # 返回对象的字符串表达

compile("print('Hello')",'test.py','exec') # 编译字符串成为code对象

eval("1 + 1") # 解释字符串表达式。参数也可以是compile()返回的code对象

exec("print('Hello')") #
解释并执行字符串，print('Hello')。参数也可以是compile()返回的code对象

Python内置(built-in)函数随着python解释器的运行而创建。在Python的程序中，你可以随时调用这些函数，不需要定义。最常见的内置函数是:

print("Hello World!")

在Python教程中，我们已经提到下面一些内置函数:

基本数据类型 type()

反过头来看看 dir() help() len()

词典 len()

文本文件的输入输出 open()

循环设计 range() enumerate() zip()

循环对象 iter()

函数对象 map() filter() reduce()

下面我采取的都是实际的参数，你可以直接在命令行尝试效果。

数学运算

abs(-5) # 取绝对值，也就是5

round(2.6) # 四舍五入取整，也就是3.0

pow(2, 3) # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5

cmp(2.3, 3.2) # 比较两个数的大小

divmod(9,2) # 返回除法结果和余数

max([1,5,2,9]) # 求最大值

min([9,2,-4,2]) # 求最小值

sum([2,-1,9,12]) # 求和

类型转换

int("5") # 转换为整数 integer

float(2) # 转换为浮点数 float

long("23") # 转换为长整数 long integer

str(2.3) # 转换为字符串 string

complex(3, 9) # 返回复数 3 + 9i

ord("A") # "A"字符对应的数值

chr(65) # 数值65对应的字符

unichr(65) # 数值65对应的unicode字符

bool(0) # 转换为相应的真假值，在Python中，0相当于False

在Python中，下列对象都相当于False： [], (), {}, 0, None, 0.0, ''

bin(56) # 返回一个字符串，表示56的二进制数

hex(56) # 返回一个字符串，表示56的十六进制数

oct(56) # 返回一个字符串，表示56的八进制数

list((1,2,3)) # 转换为表 list

tuple([2,3,4]) # 转换为定值表 tuple

slice(5,2,-1) # 构建下标对象 slice

dict(a=1,b="hello",c=[1,2,3]) # 构建词典 dictionary

序列操作

all([True, 1, "hello!"]) # 是否所有的元素都相当于True值

any(["", 0, False, [], None]) # 是否有任意一个元素相当于True值

sorted([1,5,3]) # 返回正序的序列，也就是[1,3,5]

reversed([1,5,3]) # 返回反序的序列，也就是[3,5,1]

类，对象，属性

# define class
class Me(object):

    def test(self):

        print "Hello!"

def new_test():
    print "New Hello!"

me = Me()

hasattr(me, "test") # 检查me对象是否有test属性

getattr(me, "test") # 返回test属性

setattr(me, "test", new_test) # 将test属性设置为new_test

delattr(me, "test") # 删除test属性

isinstance(me, Me) # me对象是否为Me类生成的对象 (一个instance)

issubclass(Me, object) # Me类是否为object类的子类

编译，执行

repr(me) # 返回对象的字符串表达

compile("print('Hello')",'test.py','exec') # 编译字符串成为code对象

eval("1 + 1") # 解释字符串表达式。参数也可以是compile()返回的code对象

exec("print('Hello')") # 解释并执行字符串，print('Hello')。参数也可以是compile()返回的code对象

其他

input("Please input:") # 等待输入

globals() # 返回全局命名空间，比如全局变量名，全局函数名

locals() # 返回局部命名空间

基本数据类型 type() dir() len()

文本文件的输入输出 open()

循环设计 range() enumerate() zip()

Note: range好像只能生成整数类型的range，但是可以使用np.arange(0,1,0.1)来生成float类型的range。

循环对象 iter()

函数对象 map() filter() reduce()

`zip([iterable,])`

这个函数返回一个含元组的列表，具体请看例子。

l1 = ('You gotta', 'the')

l2 = ('love', 'built-in')

out = []

if len(l1) == len(l2):

    for i in range(len(l1)):

        out.append((l1[i], l2[i]))

# out = [('You gotta', 'love'), ('the', 'built-in)]

或者这么写：

l1 = ['You gotta', 'the']

l2 = ['love', 'built-in']

out = zip(l1, l2) # [('You gotta', 'love'), ('the', 'built-in)]

如果你想得到倒序的话加上 * 操作符就可以了。

print zip(*out)

# [('You gotta', 'the'), ('love', 'built-in')]

Note: zip函数中的参数len不同，则只取len短的为准

Zipping and unzipping lists and iterables

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

>>> b = ['a', 'b', 'c']

>>> z = zip(a, b)

>>> z

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

>>> zip(*z)

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

多个序列的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()函数起到了聚合列表的功能。

=[1,2,3,4,5,6]

>>> # Using iterators

>>> group_adjacent=lambdaa, k:zip(*([iter(a)]*k))

>>> group_adjacent(a,3)

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

>>> group_adjacent(a,2)

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

>>> group_adjacent(a,1)

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

>>> # Using slices

>>> fromitertoolsimportislice

>>> group_adjacent=lambdaa, k:zip(*(islice(a, i,None, k)fori inrange(k)))

>>> group_adjacent(a,3)

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

>>> group_adjacent(a,2)

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

>>> group_adjacent(a,1)

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

,)]
使用zip & iterators实现推拉窗(n-grams)

>>> fromitertoolsimportislice

>>> defn_grams(a, n):

... z =(islice(a, i,None)foriin range(n))

... returnzip(*z)

...

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

>>> n_grams(a, 3)

[(1,2,3

),

 (

2,3,4), (3,4,5

),

 (

4,5,6)]

>>> n_grams(a, 2)

[(1,2), (2,3

),

 (

3,4), (4,5

),

 (

5,6)]

>>> n_grams(a,4)

[(1,2,3,4

),

 (

2,3,4,5

),

 (

3,4,5,6)]

使用zip反相字典对象

>>> m ={"a":1,"b":2,"c":3,"d":4}

>>> m.items()

[("a",1), ("c",3), ("b",2), ("d",4)]

>>> zip(m.values(), m.keys())

[(1,"a"), (3,"c"), (2,"b"), (4,"d")]

>>> mi =dict(zip(m.values(), m.keys()))

>>> mi

{1:"a",2:"b",3:"c",4:"d"}

枚举函数enumerate

`enumerate(iterable [,start=0])`

如果你以前写过 C 语言，那么你可能会这么写：

for i in range(len(list)):

    # do stuff with list[i], for example, print it

    print i, list[i]

噢，不用那么麻烦！你可以使用 enumerate() 来提高可读性。

for i, item in enumerate(list):

    # so stuff with item, for example print it

    print i, item

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

S = 'abcdef'

for (index,char) in enumerate(S):

    print index

    print char

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

enumerate函数还可以接收第二个参数。

>>> list(enumerate('abc', 1))

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

简单服务器

你是否想要快速方便的共享某个目录下的文件呢？

# Python2
python -m SimpleHTTPServer

# Python 3
python3 -m http.server

这样会为启动一个服务器。

最大 & 最小元素(heapq.nlargest and heapq.nsmallest)

>>> a =[random.randint(0,100)for__inxrange(100)]

>>> heapq.nsmallest(5, a)

[3,3,5,6,8]

>>> heapq.nlargest(5, a)

[100,100,99,98,98]

使用C风格的大括号代替Python缩进来表示作用域

from __future__import braces

对Python表达式求值

我们都知道eval函数，但是我们知道literal_eval函数么？

import ast

my_list = ast.literal_eval(expr)

来代替以下这种操作：

expr = "[1, 2, 3]"

my_list = eval(expr)

对象自检

在Python 中你可以通过dir() 函数来检查对象。正如下面这个例子：

>>> foo = [1, 2, 3, 4]

>>> dir(foo)

['__add__', '__class__', '__contains__',

'__delattr__', '__delitem__', '__delslice__', ... ,

'extend', 'index', 'insert', 'pop', 'remove',

'reverse', 'sort']

[python模块导入及属性]

三元运算

三元运算是if-else 语句的快捷操作，也被称为条件运算。这里有几个例子可以供你参考，它们可以让你的代码更加紧凑，更加美观。

[on_true] if [expression] else [on_false]

x, y = 50, 25

small = x if x < y else y

all(iterable)

如果可迭代的对象(数组，字符串，列表等，下同)中的元素都是 true (或者为空)的话返回 True 。

_all = True

for item in iterable:

    if not item:

        _all = False

        break

if _all:

    # do stuff

更简便的写法是：

if all(iterable):

    # do stuff

`any(iterable)`

如果可迭代的对象中任何一个元素为 true 的话返回 True 。如果可迭代的对象为空则返回False 。

_any = False

for item in iterable:

    if item:

        _any = True

        break

if _any:

    # do stuff

更简便的写法是：

if any(iterable):

    # do stuff

`cmp(x,y)`

比较两个对象 x 和 y 。 x<y 的时候返回负数，x==y 的时候返回 0，x>y 的时候返回正数。

def compare(x,y):

    if x < y:

        return -1

    elif x == y:

        return 0

    else:

        return 1

你完全可以使用一句 cmp(x, y) 来替代。

`dict([arg])`

使用 arg 提供的条目生成一个新的字典。

arg 通常是未知的，但是它很方便！比如说，如果我们想把一个含两个元组的列表转换成一个字典，我们可以这么做。

l = [('Knights', 'Ni'), ('Monty', 'Python'), ('SPAM', 'SPAAAM')]

d = dict()

for tuple in l:

    d[tuple[0]] = tuple[1]

# {'Knights': 'Ni', 'Monty': 'Python', 'SPAM': 'SPAAAM'}

或者这样：

l = [('Knights', 'Ni'), ('Monty', 'Python'), ('SPAM', 'SPAAAM')]

d = dict(l) # {'Knights': 'Ni', 'Monty': 'Python', 'SPAM': 'SPAAAM'}

`isinstance(object, classinfo)`

如果 object 参数是 classinfo 参数的一个实例或者子类(直接或者间接)的话返回 True 。

当你想检验一个对象的类型的时候，第一个想到的应该是使用 type() 函数。

if type(obj) == type(dict):

    # do stuff

elif type(obj) == type(list):

    # do other stuff

...

或者你可以这么写：

if isinstance(obj, dict):

    # do stuff

elif isinstance(obj, list):

    # do other stuff

...

`pow(x,y[,z])`

返回 x 的 y 次幂(如果 z 存在的话则以z 为模)。

如果你想计算 x 的 y 次方，以 z 为模，那么你可以这么写：

mod = (x ** y) % z

但是当 x=1234567， y=4567676， z=56 的时候我的电脑足足跑了 64 秒！

不要用 ** 和 % 了，使用 pow(x,y,z) 吧！这个例子可以写成pow(1234567,4567676,56) ，只用了 0.034 秒就出了结果！

Local函数

想让代码看起来更加简明，可以利用 Python 的内建函数 locals() 。它返回的字典对所有局部变量的名称与值进行映射。

def test(c):

    a = {}

    a[0] = 3

    b = 4

    print(locals())

if __name__ == '__main__':

    test(8)

{'c': 8, 'b': 4, 'a': {0: 3}}

Note:使用 locals() 时要注意是它将包括所有的局部变量，它们可能比你想访问的要多。也包括传入函数的参数。

python repr() \str() 函数

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

函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式（如果没有等价的语法，则会发生SyntaxError 异常）

某对象没有适于人阅读的解释形式的话， str() 会返回与repr()等同的值。很多类型，诸如数值或链表、字典这样的结构，针对各函数都有着统一的解读方式。字符串和浮点数，有着独特的解读方式。

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'" # The repr() of a string adds string quotes and backslashes

operator.itemgetter函数

operator模块提供的itemgetter函数用于获取对象的哪些维的数据，参数为一些序号（即需要获取的数据在对象中的序号）。
a = [1,2,3]
>>> b=operator.itemgetter(1) //定义函数b，获取对象的第1个域的值
>>> b(a)
2
>>> b=operator.itemgetter(1,0) //定义函数b，获取对象的第1个域和第0个的值
>>> b(a)
(2, 1)
Note:operator.itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。

皮皮blog