python函数： 内置函数

forthttp://blog.csdn.net/pipisorry/article/details/44755423

Python内置函数

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

Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

[python build-in functions - https://docs.python.org/release/3.4.2/library/functions.html]

[https://docs.python.org/release/2.7.2/library/functions.html]

[定位Python built-in函数的源码实现]

皮皮blog

python常用内置函数举例

最常见的内置函数是:

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]

类，对象，属性

1. # define class
2. class Me(object):
3. def test(self):
4. print "Hello!"
5. def new_test():
6. print "New Hello!"
7. 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()                          # 返回局部命名空间

[Python补充03 Python内置函数清单]

皮皮blog

其它常用函数

基本数据类型  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

python内置排序函数

sorted(iterable，cmp，key，reverse）

Python内置的排序函数sorted可以对list或者iterator进行排序，官网文档见：http://docs.python.org/2/library/functions.html?highlight=sorted#sorted，该函数原型为：

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

参数解释：

iterable指定要排序的list或者iterable；

cmp为带两个参数的比较函数，指定排序时进行比较的函数，可以指定一个函数或者lambda函数；

key 是带一个参数的比较函数；

reverse升降序选择，为False或者True（降序）；

axis：指定轴进行排序；

通常用法：list.sort(axis = None, key=lambda
x:x[1],
reverse = True)

例子：
（1）用cmp函数排序
>>> list1 = [('david', 90), ('mary',90), ('sara',80),('lily',95)]

>>> sorted(list1,cmp = lambda x,y: cmp(x[1],y[1]))

[('sara', 80), ('david', 90), ('mary', 90), ('lily', 95)]

（2）用key函数排序
>>> list1 = [('david', 90), ('mary',90), ('sara',80),('lily',95)]

>>> sorted(list1,key = lambda list1: list1[1])

[('sara', 80), ('david', 90), ('mary', 90), ('lily', 95)]

（3）用reverse排序
>>> sorted(list1,reverse = True)

[('sara', 80), ('mary', 90), ('lily', 95), ('david', 90)]

（4）用operator.itemgetter函数排序
>>> from operator import itemgetter

>>> sorted(list1, key=itemgetter(1))

[('sara', 80), ('david', 90), ('mary', 90), ('lily', 95)]

>>> sorted(list1, key=itemgetter(0))

[('david', 90), ('lily', 95), ('mary', 90), ('sara', 80)]

（5）多级排序
>>> sorted(list1, key=itemgetter(0,1))

[('david', 90), ('lily', 95), ('mary', 90), ('sara', 80)]

[由 sort 中 key 的用法浅谈 python]

[https://wiki.python.org/moin/HowTo/Sorting/]

[Python中的sorted函数以及operator.itemgetter函数]

from:http://blog.csdn.net/pipisorry/article/details/44755423

ref:Python 内置函数

Nifty Python tricks

Python built-in functions are awesome. Use them!

Python: Tips, Tricks and Idioms

30 Python Language Features and Tricks You May Not Know About