内置函数流程图：https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac
什么是内置函数？就是Python给你提供的，拿来直接用的函数，比如print，input等等。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。
以下我们将列出比较重要的函数：
1、作用域相关的：
locals ：函数会以字典的类型返回当前位置的全部局部变量。
globals ：函数以字典的类型返回全部全局变量。
def test(): name = 'wang' print(locals()) test() # 运行结果： {'name': 'wang'}
2、字符串执行相关的： eval、exec、compile
2.1：eval 执行字符串类型的代码，并返回最终结果。
print（eval（‘3+4’）） # 执行字符串里面的代码 运行结果： 7 ret = eval('{"name":"老司机"}') # print(ret) 执行输出： {'name': '老司机'}
总结： eval的作用相当于拨开字符串2边的引号，执行里面的代码，在文本输入和字符串转换时常用
2.2：exec 执行字符串类型的代码，流程语句。
print(exec('3+4')) 执行输出： None ret1 = ''' li = [1,2,3] for i in li: print(i) ''' print(exec(ret1)) 执行输出： 1 2 3 None eval和exec 功能是类似的都是拨开引号，执行内部代码： 区别： 1.eval有返回值,exec没有没有值 2.exec适用于有流程控制的,比如for循环。eval只能做一些简单的。
注意在工作中不能使用这个函数。
2.3：compile：将字符串类型的代码编译。代码对象能够通过exec语句来执行或eval()进行求值。
code1 = 'for i in range(0,3): print (i)' compile1 = compile(code1,'','exec') # 固定格式，中间有分隔 exec (compile1) 执行结果： 0 1 2
3、输入输出相关 input、print：
input;函数接受一个标准输入数据，返回为string类型
print：打印输出
#print(self, *args, sep=' ', end=' ', file=None) print(333,end='') print(666,) 执行输出： 333666 # 默认是用空格拼接 print(11, 22, 33) 执行输出： 11 22 33 sep 将每一个字符串拼接起来，这里指定使用| print(11, 22, 33, sep = '|') 执行输出： 11|22|33 #输出方式，当file = None默认是向屏幕输出 with open('log.txt',encoding='utf-8',mode='w') as f1: print('5555',file=f1) 执行程序，查看log.txt文件内容为: 555
4、内存相关 hash 、 id：
4.1 ：id 用于获取对象的内存地址
a = 123 print(id(a)) 执行输出： 1500668512
4.2：hash 获取一个对象(可哈希对象：int、str、Bool、tuple)的哈希值
print(hash(123)) #数字不变 print(hash('123')) # 字符串会进行hash 执行输出： 123 4876937547014958447 # true和False的哈希值对应1和0
5、模块相关 __import__，它其实使import的原生，import time 类似等于 time =__import__('time')
__import__ :函数用于动态加载类和函数。适用于代码中。
6、调用相关：
6.1：callable 函数用于检查一个对象是否可调用。如果返回True，object仍然可能调用失败；但是如果返回False，调用对象object绝对不会成功调用。
def func1(): print(555) a = 3 f = func1 print(callable(f)) print(callable(a)) # 函数或则类的对象的方法，字符串是不行的 执行输出： True False
print(callable(print)) # 显然这里是可以调用print的，所以结果是True # callable其实就是判断一个对象是否是函数，是就返回True，其他类型直接返回False
7、查看内置属性：
dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
如果参数包括方法__dir__(),该方法将被调用。如果参数不包括__dir__(),该方法将最大限度地收集参数信息。
print(dir(list)) 执行输出： ['__add__', '__class__', '__contains__'...]
8、迭代器、生成器相关：
8.1：range 函数可创建于一个整数对象，一般用于在for循环中。
8.2：next 内部实际使用了__next__方法，返回迭代器的下一个项目。
# 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) #next内部封装了__next__方法,都是求下一个值 print(x) except StopIteration: # 遇到StopIteration就退出循环 break
执行输出：
1
2
3
4
5
8.3：iter 函数用于生成迭代器（将一个可迭代对象，转化为一个迭代器）。
from collections import Iterable from collections import Iterator l = [1,2,3] print(isinstance(l,Iterable)) # 判断是否可迭代 print(isinstance(l,Iterator)) # 判断是否为迭代器 执行输出： True False from collections import Iterable from collections import Iterator l = [1,2,3] l1 = iter(l) #生成迭代器 print(isinstance(l1,Iterable)) print(isinstance(l1,Iterator)) 执行输出： True True
9、数字相关：
9.1：bool 用于将给定参数转化为布尔类型，如果没有参数，返回False。
9.2：int 用于将一个字符串或数字转换为整型。
print(int()) print(int('12')) print(int(3.6)) print(int('0100',base=2)) # 将2进制的 0100 转化成十进制。结果为 4 执行输出： 0 12 3 4
9.3：float 用于将整数和字符串转化成浮点类型
9.4：complex 用于创建一个值为 real + imag*j 的复数或者转化一个字符串为复数。如果第一个参数为字符串，则不需要指定第二个参数
print(type(3.14)) print(float(3)) 执行输出： <class 'float'> 3.0 #保留两位小数： a = 0.005 print(float('%.2f'%a)) 执行结果: 0.01
9.5:进制的转化
✴bin：将十进制转换成二进制并返回。 ✴oct：将十进制转化成八进制字符串并返回。 ✴hex：将十进制转化成十六进制字符串并返回。 print(bin(5)) print(oct(7)) print(hex(10)) #10用a表示 执行输出： 0b101 0o7 0xa
#数值
print(format(3, 'b')) # 二进制
print(format(97, 'c')) # 转换成unicode字符
print(format(11, 'd')) # 十进制
print(format(11, 'o')) # 八进制
print(format(11, 'x')) # 十六进制(小写字⺟)
print(format(11, 'X')) # 十六进制(大写字⺟)
print(format(11, 'n')) # 和d一样
print(format(11)) # 和d一样
#浮点
print(format(123456789, 'e')) # 科学计数法. 默认保留留6位小数
print(format(123456789, '0.2e')) # 科学计数法. 保留留2位小数(小写)
print(format(123456789, '0.2E')) # 科学计数法. 保留留2位小数(大写)
print(format(1.23456789, 'f')) # 小数点计数法. 保留留6位小数
print(format(1.23456789, '0.2f')) # 小数点计数法. 保留留2位小数
print(format(1.23456789, '0.10f')) # 小数点计数法. 保留留10位小数
print(format(1.23456789e+10000, 'F')) # 小数点计数法.
10、数学运算：
✴abs：函数返回数字的绝对值。 ✴divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。 round：保留浮点数的小数位数，默认保留整数。 pow：求x**y次幂。（三个参数为x**y的结果对z取余） print(abs(-20)) #绝对值 执行输出： 20 print(divmod(10,3)) #计算除数与被除数的结果 执行输出：(3, 1) print(round(3.1415)) #默认取整 执行输出： 3 print(round(3.1415,2)) # 保留两位 3.14 print(pow(2,3,5)) #求x**y次幂（三个参数为x**y的结果对z取余） #解释：这里为3个参数，2的3次方，结果为8。用8和5做除法，取余为3，最终输出3 ✴✴✴sum：对可迭代对象进行求和计算（可设置初始值）。 ✴✴✴min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。 ✴✴✴max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。 print(sum([1,2,3,4])) # 10 #注意，sum最多只有2个参数，且里面必须是可迭代对象。 ret = max([1,2,-5],key=abs) # 按照绝对值的大小，返回此序列最大值 print(ret) # 结果 -5 key表示定义规则
ret = max([1,2,-5],key=lambda x:x>1)
print(ret) # 2
11、和数据结构相关：
列表和元祖 ✴✴✴list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。 ✴✴✴tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。 相关内置函数 ✴✴✴reversed：将一个序列翻转，并返回此翻转序列的迭代器。 slice：构造一个切片对象，用于列表的切片。 ite = reversed(['a',2,3,'c',4,2]) for i in ite: print(i) 执行输出： 2 4 c 3 2 a li = ['a','b','c','d','e','f','g'] sli_obj = slice(3) #从0切到3 print(li[sli_obj]) 执行输出： ['a', 'b', 'c'] 如果有10个列表，统一切前3个，sli_obj可能有点用 slice几乎用不到 slice可以定义一个切片规则
12、字符串相关：
✴✴✴str：将数据转化成字符串。 ✴✴✴format:用于格式化输出。 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐 print(format('test', '<20')) print(format('test', '>20')) print(format('test', '^20')) 执行输出 test test test ✴✴✴bytes：用于不同编码之间的转化 # 编码转换，将unicode转换为utf-8 #方法一 s1 = '老司机' s2 = s1.encode('utf-8') print(s2) #print(s2.decode('utf-8')) #解码 执行输出： b'xe8x80x81xe5x8fxb8xe6x9cxba' #方法二 s1 = '老司机' print(bytes(s1,encoding='utf-8')) # 结果于上一致
总结：bytes:只能编码，将unicode--->非unicode，不能解码
***bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。 ret = bytearray('alex',encoding='utf-8') #4个字母对应的ascii顺序[97,108,101,120] print(id(ret)) print(ret) print(ret[0]) #97 是ascii码的顺序 ret[0] = 65 #65是大写a的位置 print(ret) print(id(ret)) 执行输出： 2177653717736 bytearray(b'alex') 97 bytearray(b'Alex') 2177653717736 ***memoryview：本函数是返回对象obj的内存查看对象。所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的
代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。 ret = memoryview(bytes('你好',encoding='utf-8')) print(len(ret)) # utf-8的bytes类型，放在一个list中 [xe4,xbd,xa0,xe5,xa5,xbd] print(ret) print(bytes(ret[:3]).decode('utf-8')) print(bytes(ret[3:]).decode('utf-8')) print('你好'.encode('utf-8')) 执行输出： 6 <memory at 0x0000016FD6AC0108> 你 好 b'xe4xbdxa0xe5xa5xbd' ✴ord:输入字符找该字符编码的位置 ✴chr:输入位置数字找出其对应的字符 ascii:是ascii码中的返回该值，不是就返回u... print(ord('a')) #ascii码的位置 print(chr(98)) #98对应a print(ord('中')) #按照unicode查找 print(ascii('中')) #不是ascii码就返回u... 执行输出： 97 b 20013 'u4e2d' ✴✴✴repr:返回一个对象的string形式（原形毕露）。 #%r 原封不动的写出来 name = 'taibai' print('我叫%r' % name) #repr 原形毕露 print(repr('{"name":"alex"}')) print('{"name":"alex"}') 执行输出： 我叫'taibai' '{"name":"alex"}' {"name":"alex"}
13、数据集合：
✴✴✴dict：创建一个字典。 ✴✴✴set：创建一个集合。 frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 相关内置函数 ✴✴✴len:返回一个对象中元素的个数。 ✴✴✴sorted：对所有可迭代的对象进行排序操作。 li = [1,2,7,8,5,4,3] print(sorted(li)) #默认升序 执行输出： [1, 2, 3, 4, 5, 7, 8] #改变默认值排序： li = [1,-2,-7,8,5,-4,3] print(sorted(li,reverse=True,key=abs)) 执行输出： [8, -7, 5, -4, 3, -2, 1] ✴✴✴enumerate:枚举，返回一个枚举对象。 (0, seq[0]), (1, seq[1]), (2, seq[2]) li = ['jack', 'rose', 'wusir', '嫂子', '老司机'] print(enumerate(li)) print('__iter__' in dir(enumerate(li))) print('__next__' in dir(enumerate(li))) 执行输出： <enumerate object at 0x00000223DD887828> True True #enumerate 是一个迭代器： li = ['jack', 'rose', 'wusir', '嫂子', '老司机'] for i in enumerate(li): print(i) 执行输出： (0, 'jack') (1, 'rose') (2, 'wusir') (3, '嫂子') (4, '老司机') 返回结果为：列表元素的索引以及对应的值 #enumerate的第2个参数，表示从多少开始。默认从1开始 li = ['jack', 'rose', 'wusir', '嫂子', '老司机'] for k,v in enumerate(li,10): print(k,v) 执行输出： 10 jack 11 rose 12 wusir 13 嫂子 14 老司机 ✴all：可迭代对象中，全都是True才是True ✴any：可迭代对象中，有一个True 就是True print(all([1,2,True,0])) print(any([1,'',0])) 执行输出： False True ✴✴✴zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同 print('__iter__' in dir(zip(l1,l2,l3,l4))) print('__next__' in dir(zip(l1,l2,l3,l4))) 执行输出： True True zip也是一个迭代器 zip 拉链方法 形成元组的个数与最短的可迭代对象的长度一样 l1 = [1, 2, 3, 4] l2 = ['a', 'b', 'c', 5] l3 = ('*', '**', (1,2,3), 777) z = zip(l1,l2,l3) for i in z: print(i) 执行输出： (1, 'a', '*') (2, 'b', '**') (3, 'c', (1, 2, 3)) (4, 5, 777) 我们把list当做列向量来看就很好理解了，zip就是拉链，把一件挂着的衣服拉起来。这就是zip的功能。所以 当做列向量看，就是拉起来的拉链了。 而转置的z就是把拉链放水平，多形象！
#注意：zip结果取决于最短的一个,返回的数据是元组
面试题，必考zip
14、补充的最重要的几个内置方法：需要注意的时，以下的函数他们都为我们实现了循环取值的功能。所以搭配着lamada函数会很好使用。
✴✴✴filter：过滤·。 filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是True 类似于[i for i in range(10) if i > 3] #取列表中的偶数 def func(x): return x % 2 == 0 ret = filter(func,[1,2,3,4,5,6,7]) # 通过一个函数过滤,不需要一个个的取，自带的 print(ret) for i in ret: print(i)
执行输出：
<filter object at 0x0000021325A4B6D8>
2
4
6
2、li = [1,2,3,4]
print(list(filter(lambda x:x>2,li))) #[3,4]
✴✴✴map:会根据提供的函数对指定序列做映射。（map也是一个迭代器） map相当于列表生成式循环模式 1、 def square(x): #计算平方数 return x ** 2 ret = map(square,[1,2,3,4,5]) #计算列表各个元素的平方 for i in ret: print(i)
执行输出： 1 4 9 16 25
2、li = [1,2,3,4,5]
print(list(map(lambda x:x+10,li))) #[11, 12, 13, 14, 15]
✴✴✴reduce：
从左到右对一个序列的项累计地应用有两个参数的函数，以此合并序列到一个单一值。
例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 计算的就是((((1+2)+3)+4)+5)。
如果提供了 initial 参数，计算时它将被放在序列的所有项前面，如果序列是空的，它也就是计算的默认结果值了
from functools import reduce
li = [1,2,3,4,5]
def func(x,y): # x=12345
return x*10+y # reduce 是做累计算的
print(reduce(func,li))
###匿名函数：
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数.
#返回一个数的平方 使用函数方式： def func1(x): return x ** 2 使用匿名函数一行搞定： func = lambda x:x ** 2 print(func(5)) # 结果 25
上面是我们对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明
函数名 = lambda 参数 ：返回值 #参数可以有多个，用逗号隔开 #匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值 #返回值和正常的函数一样可以是任意数据类型 fun = lambda x,y:x+y print(fun(1,3)) # 结果 4 # lambda单独拿出来，没有啥意义 主要是和内置函数结合使用 lambda 函数与内置函数的结合。 sorted，map，fiter，max，min，reversed. #例1 dic={'k1': 10, 'k2': 100, 'k3': 30} print(max(dic, key=lambda x: dic[x])) #执行结果 k2 x表示dic的key,返回值就是dic[x] 也就是dic的value lambda就是字典的value ，注意这里的dic，就是字典的键 #例2 res = map(lambda x:x**2,[1,5,7,4,8]) #print(res) for i in res: print(i) 执行输出： 1 25 49 16 64
15、递归：在函数中调用本身就是递归
def func(): print("我是谁") func() func() 在python中递归的深度最大到998 def foo(n): print(n) n += 1 foo(n) foo(1) # 1、2……996
实例1：查看文件夹中的所有文件名：
import os def read(filepath, n): files = os.listdir(filepath) # 获取到当前文件夹中的所有文件 for fi in files: # 遍历⽂件夹中的⽂件, 这⾥获取的只是本层文件名 fi_d = os.path.join(filepath,fi) # 加⼊文件夹 获取到⽂件夹+⽂件 if os.path.isdir(fi_d): # 如果该路径下的文件是文件夹 print(" "*n, fi) # 就是缩进几个 read(fi_d, n+1) # 继续进⾏相同的操作 else: print(" "*n, fi) # 递归出口. 最终在这里隐含着return #递归遍历目录下所有⽂文件 read('..', 0)
1.用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb name=['oldboy','alex','wusir'] print(list(map(lambda x:x+'_sb',name))) 2、用map来处理下述l，然后用list得到一个新的列表， 列表中每个人的名字都是sb结尾 l=[{'name':'alex'},{'name':'y'}] print(list(map(lambda x:x['name']+'_sb',l))) 3、用filter来处理,得到股票价格大于20的股票名字 shares={ 'IBM':36.6, 'Lenovo':23.2, 'oldboy':21.2, 'ocean':10.2, } print(list(filter(lambda x:shares[x]>20,shares))) 4、有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。 结果：list一下[9110.0, 27161.0,......] portfolio = [ {'name': 'IBM', 'shares': 100, 'price': 91.1}, {'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'FB', 'shares': 200, 'price': 21.09}, {'name': 'HPQ', 'shares': 35, 'price': 31.75}, {'name': 'YHOO', 'shares': 45, 'price': 16.35}, {'name': 'ACME', 'shares': 75, 'price': 115.65}] print(list(map(lambda x:x['shares']*x['price'],portfolio))) 5、有下列三种数据类型， 写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个。） [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。 l1 = [1,2,3,4,5,6] l2 = ['oldboy','alex','wusir','太白','日天'] tu = ('**','***','****','*******') z=list(zip(l1,l2,tu)) print(z) 6、 v =lambda :3 print(v()) #3 7、有两个字符串列表,a和b,每个字符是由逗号分隔的一些字符,(升级题)尽量做得支持扩展 a = [ 'a,1', 'b,3,22', 'c,3,4', 'f,5', ] b=[ 'a,2,1', 'b,4', 'd,2', 'e,12', 'g,12,43', 'a,4354,6' ] # 按每个字符串的第一个值,合并a和b到c # c = [ # 'a,1,2', # 'b,3,22,4', # 'c,3,4', # 'd,2', # 'e,12', # 'f,5' # ] if len(b)>len(a): a,b = b,a c=[] for i in a: flag = False removes = None i = i.strip() li=[i[0],i[2:],] for v in b: v=v.strip() if i[0]==v[0]: li.append(v[2:]) flag,removes=True,v break print(li) c.append(','.join(li)) if flag: b.remove(removes) else: c.extend(b) print(c)
1.max的用法 import re reg = re.compile('a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*') #返回一个字符串里按字母表排序的最长子字符串 def longest(s): print(reg.findall(s)) #['abcde', 'ap', 'bcdef', ''] return max(reg.findall(s), key=len) # 此函数名必是返回一个整数的，可自定义函数 #加或不加效果相同 print(longest('abcdeapbcdefgh')) #结果 ['abcde', 'ap', 'bcdefgh', ''] bcdefgh 2.compile的用法 str = "for i in range(0,10): print(i)" c = compile(str,'','exec') print(c) #<code object <module> at 0x10141e0b0, file "", line 1> exec(c) #打印0,1,3..... 3.eval的用法 a=1 g={'a':20} print(eval("a+1",g)) #对全局变量g进行操作 返回21
实例2：二分法查找
# 另类二分法, 很难计算位置. lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789] def binary_search(ls, target): left = 0 right = len(ls) - 1 if left > right: print("不不在这里") middle = (left + right) // 2 if target < ls[middle]: return binary_search(ls[:middle], target) elif target > ls[middle]: return binary_search(ls[middle+1:], target) else: print("在这里") binary_search(lst, 567)
1.下面程序的输出结果是： d = lambda p:p*2 t = lambda p:p*3 x = 2 x = d(x) x = t(x) x = d(x) print (x) #24 2.现有两元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}] #答案一 test = lambda t1,t2 :[{i:j} for i,j in zip(t1,t2)] print(test(t1,t2)) #答案二 print(list(map(lambda t:{t[0]:t[1]},zip(t1,t2)))) #还可以这样写 print([{i:j} for i,j in zip(t1,t2)]) 3.以下代码的输出是什么？请给出答案并解释。 def multipliers(): return [lambda x:i*x for i in range(4)] print([m(2) for m in multipliers()]) 请修改multipliers的定义来产生期望的结果。 #3.以下代码的输出是什么？请给出答案并解释。 def multipliers(): return [lambda x:i*x for i in range(4)] print([m(2) for m in multipliers()]) #请修改multipliers的定义来产生期望的结果 #第一问 ：[6,6,6,6] #第二问 ： def multipliers(): return (lambda x:i*x for i in range(4)) # 不需要yield因为，for必须在推导式内也就是说必须有括号 # for i in range(4): # yield lambda x:i*x print([m(2) for m in multipliers()]) #[2,4,6]
