Python Bulit-in Function

（转载：https://www.cnblogs.com/weihengblog/p/9090702.html）
（参考：http://www.runoob.com/python/python-built-in-functions.html）

1. 内置函数列表

1	2	3	4	5
abs() 绝对值	delattr() 删除属性	hash() 哈希值	memoryview()	set() 无序不重复元素集
all() 可迭代对象元素判断	dict() 字典	help() 显示帮助信息	min() 最小项	setattr() 设置属性
any() 可迭代对象元素判断	dir()	hex() 十六进制	next() 下一个	slice() 切片
ascii() ascii码	divmod() 除	id() id地址	object()	sorted() 排序
bin() 二进制	enumerate() 枚举	input() 输入	oct() 八进制	staticmethod() 静态方法
bool() 布尔值	eval() 执行字符串表达式	int() 整数	open() 打开文件	str() 字符串表达式
breakpoint() 设置断点	exec() 执行字符串表达式或代码对象	isinstance() 实例判断	ord() 返回字符的Unicode码值	sum() 求和
bytearray() 对象的字节数组	filter() 过滤	issubclass() 子类判断	pow() x的y次方	super() 调用父类
bytes() 不可变的字节数组	float() 浮点数	iter() 生成迭代器	print() 输出	tuple() 元组
callable() 是否可调用	format() 格式化	len() 个数或长度	property() 属性	type() 对象类型判断或新的类型对象
chr() 根据Unicode码值返回字符	frozenset() 冻结的集合	list()列表	range() 整数可迭代对象	vars()
classmethod() 类的方法	getattr() 得到对象属性的值	locals() 全部局部变量	repr() 字符串表达式	zip() 压缩或解压缩
compile() 字符串表达式编译为代码	globals() 全部全局变量	map() 映射	reversed() 倒转	__import__() 导入
complex()	hasattr() 是否有属性	max() 最大项	round() 四舍五入

2. 内置函数详解

• 2.1 abs():
  返回一个数值的绝对值，参数接受整数或浮点数，如果参数是负数，返回负数的相反数

• 2.2 all(iterable):
  可迭代对象的所有元素不为0、''、False或者为空,返回True。 类似于and

• 2.3 any(iterable):
  可迭代对象中有一个元素为True返回True,否则返回False

• 2.4 ascii():类似repr()

print(ascii("abc\n")) #'abc\n'
print(ascii("你好")) #'\u4f60\u597d'

• 2.5 bin(int):
  将整数转换为二进制字符串，结果是一个有效的python表达式。

print(bin(100)) #0b1100100
a = bin(100)
print(type(a)) <class 'str'> 返回值是一个字符串

• 2.6 bool(x):
  bool类是int的子类，返回布尔值True或False。

print(bool("123")) --> True

• 2.7 breakpoint(*args, **kws):

# 之前：
foo()
import pdb; pdb.set_trace()
bar()
# 现在：
foo()
breakpoint()
bar()

• 2.7 bytearray():返回一个字节数组
  source:
  如果是一个字符串，需要指定编码，以及可选的参数errors
  如果是一个可迭代对象，其整数元素取值范围0 <= x < 256

a = bytearray("abc",encoding='utf-8',errors="失败")
print(a,type(a)) # bytearray(b'abc') <class 'bytearray'>
print(a[0]) # 97
print(a[1]) # 98
print(a[2]) # 99

• 2.8 bytes(): 返回一个新的字节对象，是一个0 <= x < 256不可变的整数序列，是bytearray()不可变版本
• 2.9 callable(object):
  如果object是可调用的，返回True。
  注：类是可以调用的，调用一个类会返回一个新的实例

>>> class A:                  # 类
...     def method(self):
...             return 0
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False

• 2.10 chr():
  通过Unicode码值返回字符,ord()的逆操作.

print(chr(98)) # b

• 2.11 classmethod():
  将函数包装成类方法。
  类方法隐式的将类作为第一个参数接收，就像实例方法接收实例一样

class Data_test2(object):
        day=0
        month=0
        year=0
    def __init__(self,year=0,month=0,day=0):
        self.day=day
        self.month=month
        self.year=year

    @classmethod
    def get_date(cls,data_as_string):
        #这里第一个参数是cls， 表示调用当前的类名
        year,month,day=map(int,string_date.split('-'))
        date1=cls(year,month,day)
        #返回的是一个初始化后的类
        return date1

    def out_date(self):
        print "year :"
        print self.year
        print "month :"
        print self.month
        print "day :"
        print self.day

那么如何调用呢？

r=Data_test2.get_date("2016-8-6")
r.out_date()

输出：

year :
2016
month :
8
day :
1

• 2.12 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1):
  将source字符串表达式编译成代码或AST对象。代码对象可以被exec()或eval()执行
  参考

• 2.13 complex([real[, imag]]):
  返回real + imag*1j

complex(1) --> (1+0j)

complex(1,2) --> (1+2j)
complex("1+2j") --> (1+2j)
complex("1+2j",1) --> TypeError: complex() can't take second arg if first is a string

• 2.14 delattr(object,name):
  参数:对象,字符串(必须是对象属性之一的名称),该函数实现删除对象指定属性的操作，只要改对象允许。与setattr()相关。

delattr(x,'name') --> del x.name

• 2.15 dict(): 创建一个字典。dict对象是一个字典类，可以实例化一个字典对象

dict(a=9) --> {'a': 9}

• 2.16 dir([object]):
  打印：
  --> 内置方法
  --> 内置属性
  --> 对象属性
  --> 对象方法
  --> 类属性
  --> 类方法
  1. 不带参数的时候：返回当前作用域的名称列表
  2. 带参数时：返回object有效属性列表
  3. 如果对象具有dir()方法，将会调用此方法，并且必须返回属性列表
     I. 如果对象是模块对象：列表包含模块的属性名
     II. 如果对象是类型或者类对象，列表包含其属性名称，并显示其父类的属性的递归。
     III. 否则列表包含对象的属性名称，其类属性的名称以及其类的基类的属性的递归。
• 2.17 divmod(a,b):两个整数作为参数，返回商和余组成的元组。使用的整除(商,余数)

print(divmod(1,2)) # (0,1)
print(divmod(4,2)) # (2,0)
print(divmod(10,3),type(divmod(10,3))) # (3,1)<class 'tuple'>

• 2.18 enumerate(iterable,start=0):
  1. 返回一个enumerate object对象,索引默认从0开始
  2. 调用enumrate object的next()方法，返回一个元组
  3. 该元组包含一个计数,从start开始和iterable迭代的值

for i in enumerate([1,2,3,4],start=0):
print(i)
输出：
(0, 1) (start,iterable)
(1, 2)
(2, 3)
(3, 4)

• 2.19 eval(expression, globals=None, locals=None):
  参数是一个字符串和可选的全局变量和局部变量。
  也用于执行任意代码对象,支持语句的动态执行

eval("print('Hello')") ---> console打印： Hello

• 2.20 exec(object[, globals[, locals]):
  这个函数支持动态执行Python代码。object必须是一个字符串或代码对象。
  如果它是一个字符串，则将该字符串解析为一组Python语句，然后执行该语句（除非发生语法错误）。
  如果它是一个代码对象，只是简单地执行它。

exec("print('Hello')") ---> console打印： Hello
eval()和exec()区别:
1. 如果是简单的表达是求值，eval()和exec()都可以
2. exec()支持字符串、代码对象、复杂的Python代码
3. eval()仅支持有效的表达式求值并返回计算结果

• 2.21 filter(function, iterable): 类似表达式的过滤。比列表推导式省内存
  1. 如果function不是None，等效于生成器表达式，比列表推导式省内存
  2. 如果function是None,等效于列表推导式

def is_odd(n):
    return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

• 2.22 float(): 将整数和字符串转换成浮点数
• 2.23 format(): 字符串格式化

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

也可以设置参数
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

数字格式化
>>> print("{:.2f}".format(3.1415926));
3.14

更多数字格式化表达参考

• 2.24 frozenset():
  返回一个新的frozenset对象，可选地使用iterable中的元素。

set(可变集合)与frozenset(不可变集合)的区别：
set 无序排序且不重复，是可变的,有add()，remove()等方法。既然是可变的，所以它不存在哈希值。基本功能包括关系测试和消除重复元素。
frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add()，remove()方法。

• 2.25 getattr(object,name[, default]):
  返回对象命名属性的值，name必须是字符串
  如果name是对象属性之一，则该结果是该属性的值。
  getattr(x,"name") ===> x.name
  如果name不存在,则返回提供default值，否则引发AttributeError

• 2.26 globals(): 以字典类型返回当前位置的全部全局变量

• 2.27 hasattr(object,name):
  参数是一个对象和一个字符串。如果字符串是对象的一个属性，则返回True，否则返回False。
  它的实现是通过调用getattr(object, name)并查看它是否引发一个AttributeError。
  在getattr()之前判断object是否含有某个属性

• 2.28 hash():
  返回该对象的哈希值（如果有的话）， 哈希值应该是一个整数。
  哈希值用于在查找字典时快速地比较字典的键。
  相等数值的哈希值相同（即使它们的类型不同，比如1和1.0）.

• 2.29 help():调用内置的帮助系统。

• 2.30 hex():将整数转换为以“0x”为前缀的小写十六进制字符串

• 2.31 id(): 返回对象的内存地址
  返回一个对象的“身份”。
  这是一个整数，它保证在该对象的生命周期内是唯一的和恒定的。
  具有不重叠寿命的两个对象可以具有相同的id()值。

• 2.32 input([prompt]):
  如果存在提示符参数，则将其写入标准输出而不带结尾换行符。
  然后该函数从输入中读取一行，将其转换为一个字符串（剥离尾随的换行符），然后返回该行。
  当读取到EOF时，会产生EOFError。

input("input:") ---> console：input:

• 2.33 int():
  从数字或字符串(x)构造并返回一个整数对象
  如果没有给出参数，则返回0。
  如果 x 是一个数字，返回 x.int()。对于浮点数，这将截断为零。

• 2.34 isinstance(object, classinfo):
  instance(实例,类型)
  如果object是clsaainfo的一个实例（或者是classinfo的直接、间接或虚拟子类的实例），那么则返回true。
  如果object不是给定类型的对象，则该函数始终返回false。
  如果classinfo是类型对象的元组（或者其他这样的元组），如果object是任何类型的实例，则返回true。
  如果classinfo不是类型或类型组成的元祖和此类元组，则会引发TypeError异常。

• 2.35 issubclass(class, classinfo):
  issubclass(类,或父类)
  如果 class 是classinfo的子类(直接、 间接或 虚拟) 则返回 true 。
  一个类被认为是它自己的一个子类。
  任何其他情况下，会引发TypeError异常。

• 2.36 iter(object[, sentinel]):
  1. 返回一个迭代器对象。
  2. 根据第二个参数:
  没有第二个参数，object必须是一个支持迭代协议（iter()方法）的容器对象，或者它必须支持序列协议
  第二个参数sentinel，那么object必须是一个可调用的对象。 object.next()

• 2.37 len():返回对象的长度（项目数量）。

• 2.38 list():list不是一个函数，它实际上是一个可变的序列类型

• 2.39 locals():函数会以字典类型返回当前位置的全部局部变量。当locals()在函数代码块中调用时会返回自由变量，但是在类代码块中不会。

• 2.40 map(function, iterable, ...):
  1. 返回一个迭代器
  2. 对iterable的每个项应用function，并yield结果。

• 2.41 max():
  返回iterable中的最大项或两个或更多个参数中最大的项。
  max(iterable, *[, key, default])
  max(arg1, arg2, *args[, key])

• 2.42 memoryview(obj):
  返回给定参数的内存查看对象(Momory view)。
  所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'

• 2.43 min():
  返回可迭代中的最小项或两个或更多个参数中的最小项。

• 2.44 next(iterator[, default]):
  通过调用next()方法从迭代器中检索下一个项目。如果给出default，则在迭代器耗尽时返回，否则引发StopIteration。

• 2.45 object():
  返回一个新的无特征的对象。
  该函数不接受任何的参数。

• 2.46 oct():将整数转换为八进制字符串。

• 2.47 open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
  打开 file 并返回一个相应的文件对象.如果文件不能被打开, 抛出 OSError 异常.
  文件打开模式mode以及文件对象的方法

• 2.48 ord():
  给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode代码点的整数。

• 2.49 pow():返回x的y次方; 如果提供z参数， 返回x 的y次方再除以z的余数
  pow(x,y) 等价于 x ** y
  pow(x,y,z) 等价于 x ** y % z

pow(100, 2) --> 10000

• 2.50 print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False):
  1. 将object打印到文本流file，由sep分隔，尾部接end。
  2. sep, end 和 file 如果提供这三个参数的话，必须以关键参数的形式。

• 2.51 property():返回一个property 属性。

class Person(object):
        def __init__(self,name,age):
                self.name = name
                self.age = age

        def gettx(self):
                return self.name

        def setx(self,name):
                self.name=name

        def delx(self):
                del self.name

x = property(gettx, setx, delx, "I'm the 'x' property.")
p = Person(name,age)
#如果 p 是 Person 的实例化, p.x 将触发 getter, p.x = value 将触发 setter ， del p.x 触发 deleter
#如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。

• 2.52 range() 函数可创建一个整数列表，一般用在 for 循环中。
  range(stop)
  range(start, stop[, step])

>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]

• 2.53 repr():
  将对象转化为供解释器读取的形式。

>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

• 2.54 reversed(seq):
  返回一个反向iterator。seq必须是具有reversed()方法或支持序列协议（len()方法和getitem()方法，整数参数从0开始）。

• 2.55 round(number[, ndigits]):
  四舍五入
  返回number舍入到小数点后ndigits位的浮点值。如果省略ndigits，将返回最接近输入的整数。

• 2.56 set():
  函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

• 2.57 setattr():
  它与getattr()相对应。参数是一个对象、一个字符串和一个任意值。
  该字符串可以命名现有的属性或新的属性。
  如果该对象允许，该函数将该值分配给该属性。

setattr(x, 'foobar', 123)等同于x.foobar = 123

• 2.58 slice():
  class slice(stop)
  class slice(start, stop[, step])
  返回表示由范围（start， stop， step）指定的一组slice索引对象。

• 2.59 sorted(iterable[, key][, reverse]):依据iterable中的元素返回一个新的排好序的列表。
  iterable[, key][, reverse]
  key指示一个带有一个参数的函数，它用于从列表的每个元素中提取比较的关键字：key=str.lower
  reverse是一个布尔值。如果设置为True，那么列表中元素反过来比较来排序。

• 2.60 staticmethod():
  @ staticmethod 为函数声明一个静态方法。
  类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()

• 2.61 str()：
  返回一个object的str版本
  repr:对象以str形式表现出来，以便辨认

• 2.62 sum(iterable[, start])：
  从左至右项目返回总数
  连接字符串序列的首选方法是通过调用''.join(sequence)的方式

• 2.63 super(type[, object-or-type])：
  返回一个调用父类或者type同级类的委托方法
  访问类中被覆盖的继承方法时很有用
  1. 在单继承中，super()和其他编程语言类似，使用super()来引用父类，而不必明确命名它们
  2. 动态执行环境中，支持协同多继承。
  用例参考

• 2.64 tuple([iterable]):元组
  tuple实际上是一个不可变的序列类型，而不是一个函数

• 2.65 type():
  class type(object)
  class type(name, bases, dict)
  使用一个参数，返回对象的类型。
  返回值是一个类型对象，并且通常与object.class返回的对象相同。
  建议使用isinstance()内置函数来测试对象的类型，因为它考虑了子类。
  有三个参数，返回一个新的类型对象。这本质上是class语句的动态形式。

• 2.66 vars([object]):
  返回一个模块、字典、类、实例或者其它任何一个具有dict属性的对象的dict属性。

>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
...     a = 1
... 
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}

• 2.67 zip(iterables):
  创建一个迭代器，聚合来自每个迭代器的元素。
  返回一个由元组构成的迭代器
  当最短的输入迭代耗尽时，迭代器停止。 以短的为标准
  zip()当迭代器元素不一致时，循环停止在较短的迭代器元素，较长的迭代器元素会被舍弃。
  zip()结合运算符可用于解压缩列表

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

• 2.68__import__():
  通过 import 语句调用此函数。