python函数： 内置函数

http://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常用内置函数

数学运算

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

round(number, ndigits=None)                      # 四舍六入五成双

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])                 # 求和

round(number, ndigits=None)四舍六入五成双

Python2中“四舍五入”，round()的结果就是我们所理解的四舍五入，round(1.5)=2，round(2.5)=3。
Python3中“四舍六入五成双”，对round()函数有较大改动，例如round(1.5)=2，而round(2.5)却等于2，只有round(2.6)才等于3。

五成双的意思是，高位为单数则进1凑成双数，高位为双数则不进位。For the built-in types supporting round(), values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice.当一个值刚好在两个边界的中间的时候， round 函数返回离它最近的偶数。 这也是“银行家式舍入法”，用意是一半舍一半入，如果碰到0.5全入，那么银行觉得自己亏了，银行希望和用户要风险对半。不光Python，其他的计算机语言都是这个方法，
例如C语言和Basic语言。

round(1.5)
Out[19]: 2
round(2.5)
Out[20]: 2
round(3.5)
Out[21]: 4

round(-1.5)
Out[38]: -2
“四舍六入五成双”计数方法的作用是让统计数据更公平，降低舍入的误差。

对小数进行round()时，取2位小数结果却是：

round(1.525, 2)
Out[4]: 1.52
round(1.515, 2)
Out[5]: 1.51

from decimal import Decimal
print(round(1.525, 2))
print(Decimal(1.525))
print(round(1.515, 2))
print(Decimal(1.515))
print(round(1.145, 2))
print(Decimal(1.145))
1.52
1.524999999999999911182158029987476766109466552734375
1.51
1.5149999999999999023003738329862244427204132080078125
1.15
1.145000000000000017763568394002504646778106689453125

实际1.525用二进制转化的是有精度损失，部分小数无法完全用二进制表示，这是根本所在。round 本身没有问题，而是二进制保存的值有点误差导致的。

[python3：小数位的四舍五入（用两种方法解决round 遇5不进）]

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 秒就出了结果！

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) 来替代。

类型转换

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

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

float(str)

float存在的问题：

1 python ValueError: could not convert string to float.原因：数据中存在空字符串''，导致无法转换成float。

2 精度问题

print(float('39.89245') * 10000)
398924.49999999994

这里需要使用decimal模块解决，参考[python模块：数字处理:decimal模块]

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

类型转换

int(str,base) ：str为base进制，默认转换为十进制整型

>>> int('11',2)    3

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

序列操作

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

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

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

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

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

sorted(iterable, *, key=None, reverse=False)¶

Python内置的排序函数sorted可以对iterable对象进行排序，Return a new sorted list from the items in iterable.

py2中该函数原型为 sorted(iterable[, cmp[, key[, reverse]]])

参数解释：

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

cmp为带两个参数的比较函数，指定排序时进行比较的函数，可以指定一个函数或者lambda函数。但是py3已弃用其他语言都常用的cmp参数，为什么要这么处理呢？  1 为了节省内存，也可能与内存没什么卵关系（In Py3.0, the cmp parameter was removed entirely (as part of a larger effort to simplify and unify the language, eliminating the conflict between rich comparisons and the __cmp__() magic method).意思就是为了简化和统一Python语言，于是就把sort()方法中的cmp参数给取消掉了）。2 另一个解释是：这是因为cmp方法本身也是针对对象的特定元素来进行比较的，直接使用特定元素的值更快捷、效率更高。这也说明了cmp虽然比较的是两个，但不是两两都比较，a>b,b>c则a就>c，而不能通过a<c这种cmp指定，指定了也可能没用，结果不确定。

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

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

axis：指定轴进行排序；

Note:

1 list直接排序的通常用法：list.sort(axis = None, key=lambdax:x[1],reverse = True)，这里list本身会变成有序的，而sorted不会变，除非list = sorted(list)重新赋值。

2 对dict对象排序sorted(dict)返回的只是dict.keys()的排序结果，也就是sorted(dict)相当于sorted(dict.keys())，dict.keys()是可迭代对象，返回列表。sorted(dict({1: 2})) 返回 [1]。

例子：
（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]

[HowTo/Sorting - Python Wiki]

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

示例

通过内建函数“sorted”来实现：让其通过序列长度来从小到大排序

创建一个新的元组（s，t），并把它作为“sorted”的第一个参数。我们将从“sorted”得到一个返回的列表。因为我们使用内置的“len”函数作为“key”参数，如果s更短，“sorted”将返回[s，t], 如果t更短，将返回 [t,s]。

pytho3中使用cmp参数

在pytho3中如果想要在sort函数中使用cmp参数，需要从模块导入函数from functools import cmp_to_key，然后在sort将其赋值给key，来看例子：
 from functools import cmp_to_key
 nums = [1, 3, 2, 4]
 nums.sort(key=cmp_to_key(lambda a, b: a - b))
 print(nums)  # [1, 2, 3, 4]

python中sort函数的实现原理

1 C++内部的sort是由快排，直接插入和堆排序混合的，具体详情见STL源码剖析。
当数据量比较大的时候先用的快排，当数据量小的时候用直接插入，因为当数据量变小时，快排中的每个部分基本有序，接近直接插入的最好情况的时间复杂度O(n)，就比快排要好一点了。
2 java内部用的都是归并排序。
因为C++模板有很强的inline优化机制，比较操作相对于赋值（移动）操作要快的多（尤其是元素较大时），而java中的情况正好相反，移动（赋值）一般比比较快；另一方面，一般情况下，归并排序的比较次数小于快速排序的比较次数，而移动次数一般多于快速排序的移动次数，二者大约都是2~3倍的差距。因为这样，java标准库中的一般排序使用的归并排序的一种变种。
3 python内部的sort采用的是混合（hybrid）排序，规模小的时候采用binary insertion（折半插入排序），规模大的时候采用samplesort（样本排序）。

[python的sort函数与cmp参数]

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函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。

类，对象，属性

# 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类的子类

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
...

type() 与 isinstance()区别

class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

编译，执行

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

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

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

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

对Python表达式求值eval和literal_eval

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

import ast

my_list = ast.literal_eval(expr)

来代替以下这种操作：

expr = "[1, 2, 3]"

my_list = eval(expr)

皮皮blog

其它常用函数

输入输出

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

print("Hello World!)

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

变量

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

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

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() 时要注意是它将包括 所有 的局部变量，它们可能比你想访问的要多。也包括传入函数的参数。

基本数据类型

type() dir() len()

对象自检dir()

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

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

>>> dir(foo)

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

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

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

'reverse', 'sort']

[python模块导入及属性]

vars()函数

vars() 函数返回对象object的属性和属性值的字典对象，如果vars没有参数，就打印当前调用位置的属性和属性值 类似 locals()。

vars([object]) -> dictionary
    
    Without arguments, equivalent to locals().
    With an argument, equivalent to object.__dict__.

示例：

class Config:
    rate = 1
    
print(vars(Config))
{'__module__': '__main__', 'rate': 1, '__dict__': <attribute '__dict__' of 'Runoob' objects>, '__weakref__': <attribute '__weakref__' of 'Runoob' objects>, '__doc__': None}
c = Config()
print(vars(c))
{}

循环设计

range() enumerate() zip()

range()

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

枚举函数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')]

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

x = [1,23,45]
print(x)
y = [8,43,74]
print(y)
z = [3,34,39]
print(z)
print(list(zip(x,y,z)))
[(1, 8, 3), (23, 43, 34), (45, 74, 39)]

使用zip和iter分组相邻列表项/实现推拉窗(n-grams)

相邻2项

py3: (py2使用izip)

def pairwise(iterable):
    "s -> (s0, s1), (s2, s3), (s4, s5), ..."
    a = iter(iterable) #须先转换成iter
    return zip(a, a)

相邻k项

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

或者

>>> from itertools import islice

>>> group_adjacent=lambda a, k: zip(*(islice(a, i,None, k) for i in range(k)))

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

>>> group_adjacent(a,3)

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

>>> group_adjacent(a,1)

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

使用zip反相字典对象

>>> m ={"a":1,"b":2,"c":3,"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"}

循环对象iter()

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

其中reduce在py3中转移到[functools]中了

示例

a = [1, 2, 3]
print(list(map(lambda x: x * 2, a)))    # [2, 4, 6]
print(list(filter(lambda x: x > 1, a)))    # [2, 3]
from functools import reduce

print(reduce(lambda x, y: x * y, a))    # 6

皮皮blog

简单服务器

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

# Python2 python -m SimpleHTTPServer # Python 3 python3 -m http.server

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

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

from __future__ import braces

三元运算

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

[on_true] if [expression] else [on_false]

x, y = 50, 25

small = x if x < y else y

from:python函数： 内置函数_powmod python_-柚子皮-的博客-CSDN博客

ref: [Python build-in functions]

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