python内置函数思维导图与总结

引言

现如今在python学得越久，越是感觉到一些基础函数的重要性，不论学什么框架，当真正进入源码的时候，如果不懂得一些内置函数的含义，那将寸步难行，所以这里，我将主要总结内置函数的用法。

思维导图总结

虽然本着做一个全面的python总结，但当我画完流程图后发现，这里有些python函数比我想象中要偏门，至少在我的职业生涯中基本没碰过，虽然过一遍还是知道怎么用，可这篇博文就相当于新手教程了。我还是写一篇自备的给我后续查的东西，里面会出现一些比较跳脱的解释，也可能不对，后续改正补充。

和数字转换有关
int：

>>> int(1.75)        # 1
>>> int()        # 0
>>> int(3*4)        # 12
>>> int("3*4")        # 报错为invalid literal for int() with base 10
>>> int("12",)
1
2
3
4
5
int首先它的底层是__init__，它有两个重要的指标分别是int(x=0) -> integer和int(x, base=10) -> integer，也即是说当调用这个函数的时候一般都是采取base=10的十进制整数的形式转换，然后传递的参数应该是整型或者是字符串的整型基数，否则将会报错。

bool：

>>> bool()        # False
>>> bool("")        # False
>>> bool(None)        # False
>>> bool("  ")        # True
>>> bool("0.1")    # True
1
2
3
4
5
bool函数会返回两种值，False和True，只要有值，那么就返回True。另外bool的底层是C写的，其实很多内置函数都是cpython解释器里的。

float和complex

>>> float(1.983434242421144345)    # 结果为1.9834342424211444
>>> complex(36)    # (36+0j)

1
2
3
float只会返回小数点后16位的数字，它代表浮点数(有限循环小数，无限循环小数)，如果超过16位，那么不管四舍五入，16位直接进位。

complex是复数类型函数，当传入一个实数的时候，会创建一个新的复数，这个东西对我这类学电气的很亲切，仿佛又回到了复变函数中的复平面中，傅里叶和拉普拉斯，然而从我敲python，还没用过这个函数。。。

chr、ord、str、：

tmp_list = []
for i in range(5):
    u = chr(random.randint(65, 90))  # 生成大写字母
    l = chr(random.randint(97, 122))  # 生成小写字母
    n = str(random.randint(0, 9))  # 生成数字，注意要转换成字符串类型
    tmp = random.choice([u, l, n])    # 在u、l、n里面继续随机
    tmp_list.append(tmp)
print(tmp_list)    # ['y', '8', 'd', 'w', '6']
1
2
3
4
5
6
7
8
这是我上一篇django登录源码与第三方登录验证源码中生成一个随机验证码的代码，基本上很好的概括了这三种类型的用法。

内置高级函数相关
这里我将 filter、sorted、map、zip、enumerate 分为一类，是因为我觉得这些算python里面比较常用的高级函数，因为它们的用法多样，下面就来详细解释这些函数的语法与功能。

sorted：

>>> L = [5,2,3,1,4]
>>> sorted(L)    # [1, 2, 3, 4, 5] 
>>> L.sort()    # [1, 2, 3, 4, 5]

>>> L = [5,2,6,4,5]
>>> print(L.sort())  # None
>>> print(L)    # [2, 4, 5, 5, 6]

>>> L = [5,2,6,4,5]
>>> print(sorted(L))    # [2, 4, 5, 5, 6]
>>> print(L)    # [5, 2, 6, 4, 5]

1
2
3
4
5
6
7
8
9
10
11
12
sorted参数说明：

cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的一项;

key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;

reverse：排序规则. reverse = True 或者 reverse = False，有默认值为False，即默认是从小到大

返回值：是一个经过排序的可迭代类型，与iterable一样。

而与之相似的是sort，它们两个都是排序，但sort没有返回值，所以返回为None，并且它会改变原列表本身的性质，也就是说在原列表中做了排序，而sorted是产生了新的列表，原列表没有变化。

fliter：

from math import sqrt
def func(num):
    res = sqrt(num)
    return res % 1 == 0
ret = filter(func,range(1,101))

# new_ret = list(ret)
# print(new_ret)     # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
for i in ret:
    print(i)    
"""
1
4
9
...
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

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

map：
下面我们来看在python2下的例子，因为map在python2中会返回一个列表，但如果是python3中就是一个map对象，需要加list转换成列表类型，也可以是tuple类型：

***将元组转换成list***
>>> map(int, (1,2,3))
[1, 2, 3]
***将字符串转换成list***
>>> map(int, '1234')
[1, 2, 3, 4]
***提取字典的key，并将结果存放在一个list中***
>>> map(int, {1:2,2:3,3:4})
[1, 2, 3]
***字符串转换成元组，并将结果以列表的形式返回***
>>> map(tuple, 'agdf')
[('a',), ('g',), ('d',), ('f',)]

1
2
3
4
5
6
7
8
9
10
11
12
13
在说明之前不如来看个题目：
给你一字典a，如a={1:1,2:2,3:3}，输出字典a的key，以’,‘连接，如‘1,2,3’。要求key按照字典序升序排列(注意key可能是字符串)。

例如：a={1:1,2:2,3:3}, 则输出：1,2,3
（出自pythontip第四题 题目链接）

综合上面的案例是不是立刻就想到了用map？我觉得比较好玩的两种解法：

print(','.join(sorted(map(str,a.keys()))))    # 第一个是先映射成字符串再排序
print(','.join(map(str,sorted(a.keys()))))    # 第二个是先排序再映射成字符串
1
2
上面两条语句其实没有本质上的区别，打印的结果都是一样的，所以这也是map好用的地方。在python2中map打印出的结果是转换成了列表，在python3中需要自己手动去转换类型，

filter是执行过后的结果集合 <= 执行之前的个数，它只管筛选，不会改变原来的值。而map是执行前后元素个数不变值，可能发生改变。当map的第一个参数func为None时，这就同zip()函数了。
不论是map、filter、zip在python3中直接打印都是相应的对象，只有自己手动转类型，而在Python2中不需要，默认是列表。

zip：

l = [1,2,3,4,5]
l2 = ['a','b','c','d']
l3 = ('*','**',[1,2])
d = {'k1':1,'k2':2}
for i in zip(l,l2,l3,d):
    print(i)
"""
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')
"""

>>> s=['12a','123','234']
>>> print(list(zip(*s)))
[('1', '1', '2'), ('2', '2', '3'), ('a', '3', '4')]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
python3中地zip相当于生成器，会在遍历过程中逐次产生元组。而python2中地zip则是直接把这些元组完全生成好，并一次性地返回整份列表。如果匹配结果中海油超过预期的，那么并不会报错，只是不会显示。

enumerate：

a = {'a':1,'b':2}
for i,j in enumerate(a):    # 遍历字典
　　print(i,j)
"""
0 a
1 b
"""

a = [1,2,3,4]
for i,j in enumerate(a,1):
    print(i,j)

"""
1 1
2 2
3 3
4 4
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
enumerate中文意思叫枚举，参数为可遍历的变量，如字符串，列表，字典等； 返回值为enumerate类。那么什么是enumerate类呢？上面的两个例子便是从enumerate取出来的，索引加值，enumerate可以把各种迭代器包装为生成器，以便稍后产生输出值。另外就是第一个参数是遍历的变量，第二个参数即为指定索引，默认为0开始。

好的，这里我们还可能会想到range函数，但range的作用域范围很小，一般用于字符串和数字，如果是列表或者是字典，那要比enumerate麻烦得多，可以看下面的例子：

list = [1, 2, 3, 4, 5, 6]  
for i in range (len(list)):
  print(i ,list[i])

list2 = [1, 2, 3, 4, 5, 6]  
for i,k in enumerate(list2):
    print(i,k)
# 两个的结果最终是一样的，但上面那种比下面的麻烦，并且也比较难懂，所以如果是遍历列表或者字典的话，推荐是用enumerate

1
2
3
4
5
6
7
8
9

字符串类型代码的执行
eval、exec：

>>> print(eval("1+2+3+4"))    # 10
>>> print(exec("1+2+3+4"))    # None

>>> code = '''for i in range(10):
>>>     print(i*'*')
'''
>>> exec(code)
>>> eval(code)  
# *
# **
# ***
# ****
# *****
# ******
# *******    # exec显示
# SyntaxError: invalid syntax    # eval显示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
首先它们两个都能执行python代码，但eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。eval()函数可以有返回值，而exec()函数返回值永远为None。

所以eval可以用于有结果的简单运算，而exec可以用做简单的流程控制，另外一半建议不要轻易用eval，只能用在你明确知道你要执行的代码是什么才行，我记得Django中有一次我将它配合local一起用，虽然简单是简单，但一旦出bug，问题就大了。

compile：

code = '1 + 2 + 3 + 4'
compile = compile(code,'','eval')
print(eval(compile))    # 10

code = 'name = input("please input your name:")'
compile = compile(code,'','single')
exec(compile) #执行时显示交互命令，提示输入
print(name)
"""
please input your name:submarineas
submarineas
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值。

怎么理解这段话呢？依照我的理解就是compile是将语句转换成了一种编译格式与规则，但没有执行，需要相应的函数去运行这种编译好的规则，或者说调用，比如说exec、eval或者正则中的match匹配。另外这里的第二段代码的意思就是首先在code时拿到了这个name变量，然后通过exec的执行获取到了name，那么就可以调用name变量了，简单说还是挺方便的

反射相关
class func(object):
    name = "小黑"
    def __init__(self):
        self.age = "123"
    def write(self):
        return "helloworld"

func1 = func()

# hasattr
print(hasattr(func1, "name"))   # True
print(hasattr(func1, "self.age"))    # False
print(hasattr(func1, "write"))  # True

# getattr
print(getattr(func1,"name"))    # 小黑
print(getattr(func1,"write"))   # <bound method func.write of <__main__.func object at 0x0000026D5E65E438>>
print(getattr(func1,"write")()) # helloworld
print(getattr(func1,"self.age"))     # AttributeError: 'func' object has no attribute 'self.age'
print(getattr(func1,"__init__")())  # None
print(getattr(func1,"age","123"))  # 123

# setattr
print(hasattr(func1,"age")) # False
print(setattr(func1,"age","123"))   # None
print(hasattr(func1,"age"))   # True
print(getattr(func1,"age"))   # 123

# delattr
print(delattr(func1,"age")) # None
print(hasattr(func1,"age")) # False
print(delattr(func1,"write")) # AttributeError: write
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
总结：
hasattr： 判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。如果是方法里的属性并不能获取到。

getattr： 获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，可以在后面添加一对括号。

setattr： 给对象的属性赋值，若属性不存在，先创建再赋值。

delattr： 将对象的属性删除，无法删除方法。

关于反射，一般上述setattr、hasattr、getattr都是成双出现的，并且一般都是源码居多，比如说我之前介绍过的restframework的第三篇中视图部分的ModelViewSet的部分源码就将上述三个用在了一起，还有可能未来我要写的form表单源码中的钩子函数，还有一些基本的单例。所以这几个相当于底层吧，

其它
dir，help： 查看属性

>>> print(dir([]))     # ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '......
>>> print(help([]))    # 上面方法的名字与方法，以及一些解释
>>> help([])        # 和上面一样
1
2
3
dir是查看内置属性，或者说方法，比如说我有时候忘了某种数据类型的时候，我就可以进行查看和验证。

另外help可以从上面的例子看到，它是自带打印值的，所以里面应该是封装了print方法，另外它和dir不同是它会显示该所有的方法以及详细的解释，所以基本上所有语言里，都会有help，并且我们需要熟练help来查询帮助。

print：

# 1. end和sep关键字
>>> print("青春猪头少年不会梦到兔女郎学姐")      # 未指定输出的结束符
青春猪头少年不会梦到兔女郎学姐

>>> print("青春猪头少年不会梦到兔女郎学姐",end="")        # 指定以空值结尾。这里的end和sep都是关键字传参
青春猪头少年不会梦到兔女郎学姐
>>> print(1,2,3,4,5,sep="")      # 指定输出多个值之间的分隔符，输出12345

# 2. file关键字
>>> f = open("file","w")
>>> print("aaaa")
>>> f.close()    # 最后控制台会没有任何东西，而打印出的东西会在当前项目文件下的f文件中，有aaaa，所以这个参数的意思系统默认打印是在控制台的，但如果我们自己制定位置的话，那么控制台就不会打印了。
1
2
3
4
5
6
7
8
9
10
11
12
13
print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

参数：

objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file – 要写入的文件对象。
input：

python2
>>> user=raw_input("please input:")
please input:submarineas
>>> user
"submarineas"    # 输入成功，返回字符串
>>> user=raw_input("please input:")
please input:123
>>> user
"123"    # 依然是字符串

>>> user=input("please input:")
please input:submarineas    # 会报错
>>> user    # NameError: name 'wei' is not defined

>>> user=raw_input("please input:")
please input:1+2
>>> user
3    # 输出3，是整形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
在Python有raw_input( )和input( )，两个函数都存在，其中区别为raw_input( )将所有输入作为字符串看待，返回字符串类型，而input只能接收“数字”的输入，在对待纯数字输入时当成了某种指令，并返回所输入的数字的类型（ int, float ）。

在python3.x中raw_input( )和input( )进行了整合，去除了raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

>>> user=raw_input("please input:")
please input:1+2
>>> user
"1+2"
please input:submarineas
"submarineas"
1
2
3
4
5
6

callable：

>>> print(callable(print))    # True
>>> a = 1
>>> print(callable(a))        # False
>>> print(callable(global))    # global会飘红
1
2
3
4
callable它相当于对当前对象的每一个函数方法做了一次callable(回调)，callable也是一个内置函数，可以检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败，它的底层是取决于类是否定义了__call__方法。

当然关键字不能被callable调用，比如说是global、local等，虽然理论上它们是可调用的，但关键字的优先级要高于调用等级。

另外不仅仅只有callable，还有writable、readable等，也就是说可以用这两个函数看看是否文件可以读或者可以写。总之，它只能查变量，如果变量是函数就返回True，如果是值就是False。

总结
额，该总结的都在上面总结完了，那我只能说趁热打铁吧，下面将会开始刷剑指offer。这里的函数就先总结这么多，以后会补充的。

参考文献：

Python map()函数的用法
python中enumerate（）的用法
Python3：input()函数
Eva_J内置函数总结
————————————————
版权声明：本文为CSDN博主「submarineas」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。