内置函数

abs():返回数字的绝对值

all()：

参数：iterable -- 元组或列表。

返回值：如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；

注意：空元组、空列表返回值为True，这里要特别注意。

any():

参数:iterable -- 元组或列表。

返回值:如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。

ascii():函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 x, u 或 U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。

In [6]: ascii("你好")

Out[6]: "'\u4f60\u597d'"

In [9]: ascii("hello")

Out[9]: "'hello'"

bin():

参数：x -- int 或者 long int 数字

返回值：返回一个整数 int 或者长整数 long int 的二进制表示。

In [10]: bin(2000)

Out[10]: '0b11111010000'

In [11]: bin(2)

Out[11]: '0b10'

bool()：用于将给定参数转换为布尔类型，如果没有参数，返回 False。

In [12]: bool(0)

Out[12]: False

In [13]: bool(1)

Out[13]: True

In [14]: bool()

Out[14]: False

bytearray()：

class bytearray([source[, encoding[, errors]]])

参数：

如果 source 为整数，则返回一个长度为 source 的初始化数组；

如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。

如果没有输入任何参数，默认就是初始化数组为0个元素。

返回值：bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256

In [16]: bytearray("你好",encoding="utf-8")

Out[16]: bytearray(b'xe4xbdxa0xe5xa5xbd')

In [17]: bytearray([1,2,3])

Out[17]: bytearray(b'x01x02x03')

bytes()：

class bytes([source[, encoding[, errors]]])

参数：

如果 source 为整数，则返回一个长度为 source 的初始化数组；

如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；

如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。

如果没有输入任何参数，默认就是初始化数组为0个元素。

返回值：bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

callable()：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

In [23]: def a():

...: pass

In [24]: callable(a)

Out[24]: True

In [25]: class A():

...: pass

In [26]: callable(A)

Out[26]: True

In [28]: a =A()

In [29]: callable(a)

Out[29]: False

chr()：参数：可以是10进制也可以是16进制的形式的数字。

返回值是当前整数对应的ascii字符。

In [38]: chr(56)

Out[38]: '8'

In [39]: chr(98)

Out[39]: 'b'

classmethod()：classmethod修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A(object):

bar = 1

def func1(self):

print ('foo')

@classmethod

def func2(cls):

print ('func2')

print (cls.bar)

cls().func1() # 调用 foo 方法

A.func2() # 不需要实例化

输出结果：

func2

1

foo

compile()：compile(source, filename, mode[, flags[, dont_inherit]])

参数：

source -- 字符串或者AST（Abstract Syntax Trees）对象。。

filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。

mode -- 指定编译代码的种类。可以指定为 exec, eval, single。

flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。

flags和dont_inherit是用来控制编译源码时的标志

将一个字符串编译为字节代码

delattr():delattr(object, name)

参数：object -- 对象。name -- 必须是对象的属性。

delattr 函数用于删除属性。

delattr(x, 'foobar') 相等于 del x.foobar。

dict()

dir()

divmod()：把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

In [40]: divmod(7,2)

Out[40]: (3, 1)

enumerate()：enumerate(sequence, [start=0])

参数：

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

In [41]: seq = ['one', 'two', 'three']

In [43]: for k ,v in enumerate(seq):

...: print(k)

...: print(v)

...:

0

one

1

two

2

three

eval()：eval(expression[, globals[, locals]])

参数：

expression -- 表达式。

globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

In [44]: x = 4

In [45]: eval("3*x")

Out[45]: 12

exec()：exec(object[, globals[, locals]])

参数：

object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。

globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。

locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。

exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。

filter()：函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回True或False，最后将返回True的元素放到新列表中。

返回值：返回一个迭代器对象

过滤出1~100中平方根是整数的数：

import math

def is_sqr(x):

return math.sqrt(x) % 1 == 0

tmplist = filter(is_sqr, range(1, 101))

newlist = list(tmplist)

print(newlist)

float()

format()

frozenset()：class frozenset([iterable])

参数：iterable -- 可迭代的对象，比如列表、字典、元组等等。

返回值：返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

In [1]: frozenset(range(1,10))

Out[1]: frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9})

In [2]: frozenset("awdadawgff")

Out[2]: frozenset({'a', 'd', 'f', 'g', 'w'})

getattr()：getattr(object, name[, default])

参数：

object -- 对象。

name -- 字符串，对象属性。

default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

返回值：返回对象属性值。

globals()：globals() 函数会以字典类型返回当前位置的全部全局变量。

>>>class A(object):

... bar = 1

...

>>> a = A()

>>> getattr(a, 'bar') # 获取属性 bar 值

1

>>> getattr(a, 'bar2') # 属性 bar2 不存在，触发异常

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: 'A' object has no attribute 'bar2'

>>> getattr(a, 'bar2', 3) # 属性 bar2 不存在，但设置了默认值

3

>>>

hasattr()：hasattr(object, name),用于判断对象是否包含对应的属性。

参数：

object -- 对象。

name -- 字符串，属性名。

返回值：如果对象有该属性返回 True，否则返回 False。

hash()：用于获取取一个对象（字符串或者数值等）的哈希值。

In [4]: hash("dafjajf")

Out[4]: -8407846783282017319

help()：查看函数或模块用途的详细说明。

hex()：用于将10进制整数转换成16进制，以字符串形式表示。

In [5]: hex(5689)

Out[5]: '0x1639'

id()：函数用于获取对象的内存地址。

In [7]: a=45

In [8]: id(a)

Out[8]: 1818259856

input()

int()

isinstance()：isinstance(object, classinfo)，用来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用 isinstance()。

参数：

object -- 实例对象。

classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

issubclass()：方法用于判断参数 class 是否是类型参数 classinfo 的子类。

iter()：iter(object[, sentinel])，函数用来生成迭代器。

参数：

object -- 支持迭代的集合对象。

sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

返回迭代器对象。

len()

list()

locals()：locals() 函数会以字典类型返回当前位置的全部局部变量。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

返回字典类型的局部变量。

>>>def runoob(arg): # 两个局部变量：arg、z

... z = 1

... print (locals())

...

>>> runoob(4)

{'z': 1, 'arg': 4} # 返回一个名字/值对的字典

>>>

map()：map(function, iterable,...)，第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表。

参数：

function -- 函数

iterable -- 一个或多个序列

python3返回迭代器。

max()

memoryview()：函数返回给定参数的内存查看对象(Momory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

min()

next()：next(iterator[, default])

参数：

iterator -- 可迭代对象

default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

返回迭代器的下一个项目。

object()

oct()：将一个整数转换成8进制字符串。

open()

ord()：ord()函数是chr()函数（对于8位的ASCII字符串）或unichr()函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的Unicode字符超出了Python定义范围，则会引发一个 TypeError 的异常。

pow()：pow(x, y[, z])，方法返回xy（x的y次方） 的值。

函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

print()

property()： 函数的作用是在新式类中返回属性值。（待补充）

range()

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

reversed()：返回一个反转的迭代器。参数可以是 tuple, string, list 或 range。

round()：round( x [, n] )，方法返回浮点数x的四舍五入值。

参数：

x -- 数字表达式。

n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。

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

setattr()：setattr(object, name, value)，

参数：

object -- 对象。

name -- 字符串，对象属性。

value -- 属性值。

slice()：函数实现切片对象，主要用在切片操作函数里的参数传递。

参数：

参数说明：

start -- 起始位置

stop -- 结束位置

step -- 间距

sorted()：sorted(iterable, key=None, reverse=False)

参数：

terable -- 可迭代对象。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回重新排序的列表。

staticmethod()：返回函数的静态方法。

str()

sum()：sum(iterable[, start])

参数：

iterable -- 可迭代对象，如：列表、元组、集合。

start -- 指定相加的参数，如果没有设置这个值，默认为0。

super()：

tuple()：将列表转换为元组

type()：函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

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

zip()：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

__import__()：__import__(name[, globals[, locals[, fromlist[, level]]]])

函数用于动态加载类和函数 。

如果一个模块经常变化就可以使用 __import__() 来动态载入