函数的内置方法
abs()：
绝对值函数。如abs（-1）= 1
>>> abs(-10) 10 >>> f = abs >>> f(-1) 1 >>> abs=id >>> abs(1) 1869788224
以abs()函数为例，展示两个特性。一是，内置函数是可以被赋值给其他变量的，同样也可以将其他对象赋值给内置函数，这时就完全变了。所以，内置函数不是Python关键字，要注意对它们的保护，不要使用和内置函数重名的变量名，这会让代码混乱，容易发生难以排查的错误。
all()
接收一个可迭代对象，如果对象里的所有元素的bool运算值都是True，那么返回True，否则False。不要小瞧了这个函数，用好了，有化腐朽为神奇的特效。
>>> all([1,1,1]) True >>> all([1,1,0]) False
any()
接收一个可迭代对象，如果迭代对象里有一个元素的bool运算值是True，那么返回True，否则False。与all()是一对兄弟。
>>> any([0,0,1]) True >>> any([0,0,0]) False
ascii()
调用对象的__repr__()方法，获得该方法的返回值。__repr__()方法是由对象所属类型实现的方法。不可以简单地理解为print或echo。
>>>s = “haha” >>> ascii(s) "'haha'" >>> a = [1,2,3] >>> ascii(a) '[1, 2, 3]'
bin()、oct()、hex()
三个函数是将十进制数分别转换为2/8/16进制。
>>> i = 10 >>> bin(i) '0b1010' >>> oct(i) '0o12' >>> hex(i) '0xa'
bool()
测试一个对象或表达式的执行结果是True还是False。实际上bool是一个类，不是函数，bool()的返回值是一个布尔类型的实例。builtins中的很多函数，其实都是类，比如bytes()，str()等等。其中bool对于一个空列表或者带有0的列表，返回的是False。
>>> bool(1==2) False >>> bool(abs(-1)) True >>> bool(None) False >>>a = [] >>>bool(a) False
bytearray()
描述
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
语法
bytearray()方法语法：
class bytearray([source[, encoding[, errors]]])
参数
- 如果 source 为整数，则返回一个长度为 source 的初始化数组；
- 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
- 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
- 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
- 如果没有输入任何参数，默认就是初始化数组为0个元素。
返回值
返回新字节数组。
实例
以下实例展示了 bytearray() 的使用方法：
>>>bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'x01x02x03')
>>> bytearray('runoob', 'utf-8')
bytearray(b'runoob')
>>>
bytes()
将对象转换成字节类型。例如：s = '张三';m = bytes(s,encoding='utf-8')
>>> i=2
>>> bytes(i)
b'x00x00'
>>> s = 'haha'
>>> bytes(s)
Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
bytes(s)
TypeError: string argument without an encoding
>>> bytes(s, encoding="utf-8")
b'haha'
>>> bytes(s, encoding="GBK")
b'haha'
str()
将对象转换成字符串类型，同样也可以指定编码方式。例如：str(bytes对象，encoding='utf-8')
>>> i = 2 >>> str(i) '2' >>> b = b"haha" >>> str(b) # 注意！ "b'haha'" >>> str(b,encoding="gb2312") 'haha' >>> str([1,2,3,]) '[1, 2, 3]'
Bytes和string之间的互相转换，更多使用的是encode()和decode()方法。
callable()
判断对象是否可以被调用。如果某个对象具有__call__方法，那它就能被调用。 例如，def f1(): pass,那么callable(f1)返回True。常用于判断一个变量是否是函数。函数可调用。
>>> def f1():
pass
>>> callable(f1)
True
>>> a = "123"
>>> callable(a)
False
>>> class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
>>> f_obj = Foo("jack",20)
>>> callable(f_obj)
False
>>> callable(Foo)
True
chr()
返回某个十进制数对应的ASCII字符，例如：chr(99) = ‘c’。它可以配合random.randint(65，91)随机方法，生成随机字符，用于生产随机验证码。
import random
for i in range(10):
a = random.randint(65,91)
c = chr(a)
print(c)
ord()
与chr()相反，返回某个ASCII字符对应的十进制数，例如，ord('A') = 65
>>> ord("A")
65
>>> ord("
")
10
classmethod()、staticmethod()和property()
类机制中，用于生成类方法、静态方法和属性的函数。在面向对象章节会有详细介绍。
compile()
将字符串编译成Python能识别或执行的代码。 也可以将文件读成字符串再编译。
>>> s = "print('helloworld')"
>>> r = compile(s,"<string>","exec")
>>> r
<code object <module> at 0x000001B23E6BE660, file "<string>", line 1>
>>> r()
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
r()
TypeError: 'code' object is not callable
>>> exec(r)
helloworld
>>> eval(r)
helloworld
complex()
通过数字或字符串生成复数类型对象。
>>>complex(1, 2)
(1 + 2j)
>>> complex(1) # 数字
(1 + 0j)
>>> complex("1") # 当做字符串处理
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
使用字符串的时候，+号左右不能有空白。
delattr()、setattr()、getattr()、hasattr()
类机制中，分别用来删除、设置、获取和判断属性。后面会有详解。
dir()
显示对象所有的属性和方法。打印当前程序的所有变量。最好用的辅助函数之一。
>>> dir() ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'builtins', 'r', 's'] >>> dir([1,2,]) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
int()、float()、list()、dict()、set()、tuple()
与bool()、str()、bytes()一样，它们都是实例化对应数据类型的类。
divmod()
除法，同时返回商和余数的元组。
>>> divmod(10,3) (3, 1) >>> divmod(11,4) (2, 3)
enumerate()
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
Python 2.3. 以上版本可用，2.6 添加 start 参数。
语法
以下是 enumerate() 方法的语法:
enumerate(sequence, [start=0])
参数
- sequence -- 一个序列、迭代器或其他支持迭代对象。
- start -- 下标起始位置。
# 实例 # 以下展示了使用 enumerate() 方法的实例： >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter'] >>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] >>> list(enumerate(seasons, start=1)) # 小标从 1 开始 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')] # 普通的 for 循环 >>>i = 0 >>> seq = ['one', 'two', 'three'] >>> for element in seq: ... print i, seq[i] ... i +=1 ... 0 one 1 two 2 three # for 循环使用 enumerate >>>seq = ['one', 'two', 'three'] >>> for i, element in enumerate(seq): ... print i, element ... 0 one 1 two 2 three
通常用于对那些无法提供序号的迭代对象使用。但对于字典，依然是无序的。
eval()
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
语法
以下是 eval() 方法的语法:
eval(expression[, globals[, locals]])
参数
- expression -- 表达式。
- globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
- locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。
实例
以下展示了使用 eval() 方法的实例：
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
exec()
描述
exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。
需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。
语法
以下是 exec 的语法:
exec obj
参数
- obj -- 要执行的表达式。
返回值
exec 返回值永远为 None。
实例
以下展示了使用 exec 的实例：
实例 1
>>>exec 'print "Hello World"' Hello World # 单行语句字符串 >>> exec "print 'runoob.com'" runoob.com # 多行语句字符串 >>> exec """
...for i in range(5): ... print "iter time: %d" % i ... """ iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4
实例 2
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20
exec(expr)
exec(expr, {'x': 1, 'y': 2})
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
func()
输出结果：
60
33
34
eval() exec()
eval()只能处理单行代码而exec()可以处理多行代码
eval()有返回值，exec没有返回值
res = eval('1+3+2')
res2 = exec('1+3+2')
print('res', res, res2)
# 执行结果
res 7 None
format()
执行format()，其实就是调用该对象所属类的__format__方法。类似print功能。
>>> format("324324")
'324324'
>>> format([1,2,3])
'[1, 2, 3]'
frozenset()
描述
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法
frozenset() 函数语法：
class frozenset([iterable])
参数
- iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回值
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
实例
以下实例展示了 frozenset() 的使用方法：
>>>a = frozenset(range(10)) # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合
>>>
globals()
列出当前环境下所有的全局变量。注意要与global关键字区分！在本节的开始，我们就已经展示了它的用法。
hash()
为不可变对象，例如字符串生成哈希值的函数！
>>> hash("i am jack")
5602200374213231465
>>> hash(1)
1
>>> hash(100000)
100000
>>> hash([1,2,3,])
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
hash([1,2,3,])
TypeError: unhashable type: 'list'
>>> hash((1,2,3))
2528502973977326415
help()
返回对象的帮助文档。谁用谁知道！
>>> a = [1,2,3]
>>> help(a)
Help on list object:
class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable's items
...
id()
返回对象的内存地址,常用来查看变量引用的变化，对象是否相同等。常用功能之一！
>>> id(0) 1456845856 >>> id(True) 1456365792 >>> a = "Python" >>> id(a) 37116704
input()
接收用户输入，返回一个输入的字符串。
>>> a = input("Please input a number: ")
Please input a number: 100
>>> a
'100'
>>> type(a)
<class 'str'>
isinstance()
判断一个对象是否是某个类的实例。比type()方法适用面更广。
>>> isinstance("haha", str)
True
>>> isinstance(1, str)
False
issubclass()
issubclass(a，b),判断a是否是b的子类。
>>> class Foo:
pass
>>> class Goo(Foo):
pass
>>> issubclass(Goo, Foo)
True
iter()
制造一个迭代器，使其具备next()能力。
>>> lis = [1, 2, 3]
>>> next(lis)
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
next(lis)
TypeError: 'list' object is not an iterator
>>> i = iter(lis)
>>> i
<list_iterator object at 0x0000000002B4A128>
>>> next(i)
1
len()
返回对象的长度。不能再常用的函数之一了。
locals()
locals() 函数会以字典类型返回当前位置的全部局部变量。简单点就是返回局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
返回值：字典类型的局部变量
>>>def runoob(arg): # 两个局部变量：arg、z
... z = 1
... print (locals())
...
>>> runoob(4)
{'z': 1, 'arg': 4} # 返回一个名字/值对的字典
>>>
max()/min():
返回给定集合里的最大或者最小的元素。可以指定排序的方法！
lst=['abcdhush8','abc9iujtwertwert','abcdjlas','abcdj897h'] a = min(lst,key=len) print(a)
memoryview(obj)
返回obj的内存视图对象。obj只能是bytes或bytesarray类型。memoryview对象的使用方法如下：
>>> v = memoryview(b'abcefg') >>> v[1] 98 >>> v[-1] 103 >>> v[1:4] <memory at 0x7f3ddc9f4350> >>> bytes(v[1:4]) b'bce'
next()
通过调用迭代器的__next__()方法，获取下一个元素。
object()
该方法不接收任何参数，返回一个没有任何功能的对象。object是Python所有类的基类。
open()
打开文件的方法。在Python2里，还有一个file()方法，Python3中被废弃了。后面章节会详细介绍open()的用法。
pow()
幂函数。
>>> pow(3, 2) 9
print()
语法
以下是 print() 方法的语法:
print(*objects, sep=' ', end='
', file=sys.stdout)
参数
- objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
- sep -- 用来间隔多个对象，默认值是一个空格。
- end -- 用来设定以什么结尾。默认值是换行符 ，我们可以换成其他字符串。
- file -- 要写入的文件对象。
>>> print("www","runoob","com",sep=".") # 设置间隔符
www.runoob.com
>>>print(1)
1
>>> print("Hello World")
Hello World
>>> a = 1
>>> b = 'runoob'
>>> print(a,b)
1 runoob
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
range()
没错，这是Python内置的函数，前面已经介绍了。
repr()
repr() 函数将对象转化为供解释器读取的形式。并且返回一个对象的 string 格式。
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
reversed()
反转，逆序对象
>>> reversed # reversed本身是个类 <class 'reversed'> >>> reversed([1,2,3,4,5]) # 获得一个列表反转器 <list_reverseiterator object at 0x0000022E322B5128> >>> a = reversed([1,2,3,4,5]) >>> a <list_reverseiterator object at 0x0000022E32359668> >>> list(a) # 使用list方法将它转换为一个列表 [5, 4, 3, 2, 1]
round()
描述
round() 方法返回浮点数x的四舍五入值。
语法
以下是 round() 方法的语法:
round( x [, n] )
参数
- x -- 数值表达式。
- n -- 数值表达式。
返回值
返回浮点数x的四舍五入值。
a = round(2.33333, 2) print(a) b = round(3.555, 1) print(b) # 执行结果 2.33 3.6
slice()
返回一个切片类型的对象。slice是一个类，一种Python的数据类型。Python将对列表等序列数据类型的切片功能单独拿出来设计了一个slice类，可在某些场合下使用。
>>> s = slice(1, 10, 2) >>> s slice(1, 10, 2) >>> type(s) <class 'slice'> >>> lis = [i for i in range(10)] >>> lis [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> lis[s] # 注意用法 [1, 3, 5, 7, 9]
sum()
求和．
>>> sum(1,2,3) # 需要传入一个可迭代的对象
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
sum(1,2,3)
TypeError: sum expected at most 2 arguments, got 3
>>> sum([1,2,3]) # 传入一个列表
6
>>> sum({1:1,2:2}) # 突发奇想，作死传入一个字典
3
super()
调用父类。面向对象中类的机制相关。后面介绍。
type()
显示对象所属的数据类型。常用方法！前面已经展示过。
vars()
与dir()方法类似，不过dir()方法返回的是key，vars()方法返回key的同时还把value一起打印了。
>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': <list_reverseiterator object at 0x0000022E32359668>, 's': 'ha'}
map()
描述
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法
map() 函数语法：
map(function, iterable, ...)
参数
- function -- 函数，有两个参数
- iterable -- 一个或多个序列
返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器。
实例
以下实例展示了 map() 的使用方法：
>>>def square(x) : # 计算平方数 ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25] >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]
filter()
描述
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法
以下是 filter() 方法的语法:
filter(function, iterable)
参数
- function -- 判断函数。
- iterable -- 可迭代对象。
返回值
返回列表。
实例
以下展示了使用 filter 函数的实例：
过滤出列表中的所有奇数：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
def is_odd(n):
return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
#执行结果
[1, 3, 5, 7, 9]
过滤出1~100中平方根是整数的数：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
newlist = filter(is_sqr, range(1, 101))
print(newlist)
# 输出结果 ：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
zip()
描述
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。
如果需要了解 Pyhton3 的应用，可以参考 Python3 zip()。
语法
zip 语法：
zip([iterable, ...])
参数说明：
- iterabl -- 一个或多个迭代器;
返回值
返回元组列表。
实例
以下实例展示了 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)]
sorted()
排序方法。有key和reverse两个重要参数。
基础用法: 直接对序列进行排序
>>> sorted([36, 5, -12, 9, -21]) [-21, -12, 5, 9, 36]
指定排序的关键字。关键字必须是一个可调用的对象。例如下面的例子，规则是谁的绝对值大，谁就排在后面。
>>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 36] # 或者可以使用lambda函数指定列表的那个排序
d = {}
for i in range(10):
d[i] = i - 50
print(d)
d2 = d.items()
d[2] = 5
d3 = sorted(d2, key=lambda x:x[1]) # key后面还可以添加recerse = True进行反转排序
print(d3)
# 执行结果
# {0: -50, 1: -49, 2: -48, 3: -47, 4: -46, 5: -45, 6: -44, 7: -43, 8: -42, 9: -41}
# [(0, -50), (1, -49), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41), (2, 5)]
指定按反序排列。下面的例子，首先按忽略大小写的字母顺序排序，然后倒序排列。
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about']
hash()
描述
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
语法
hash 语法：
hash(object)
参数说明：
- object -- 对象；
返回值
返回对象的哈希值。
实例
以下实例展示了 hash 的使用方法：
>>>hash('test') # 字符串
2314058222102390712
>>> hash(1) # 数字
1
>>> hash(str([1,2,3])) # 集合
1335416675971793195
>>> hash(str(sorted({'1':1}))) # 字典
7666464346782421378
>>>
__import__(name)
这个方法为我们提供了一种通过字符串反射包、库或模块的手段。其中的name是你想要导入的库的名称的字符串。
t = __import__("time")
print(t.time())
例子中，利用字符串“time”，导入了实际的time库，并赋值给t变量。这个变量实际就相当于import time的结果。然后使用t.time()进行调用。
在某些场景下，这个方法非常有用。但是很多时候，它也存在安全问题，Python官方不建议经常使用它。
至此，除了个别遗留，近80个内置函数就基本介绍完毕。