python之路_内置函数及匿名函数

一、内置函数

　　3.6版本python共提供68种内置函数，如下图展示，现将重要内置函数的使用做如下讲解：

1、作用域相关：globals()和locals()

　　globals()：全局作用域中的变量，无论放在全局命名空间还是在局部命名空间，输出结果一样，都是全局中的变量

　　locals()：放在全局命名空间时和globals（）效果一致，放在局部命名空间输出局部空间的变量

def func():
    x = 1
    y = 2
func()
print(locals())
print(globals())
#输出结果一致，均为全局变量
def func():
    x = 1
    y = 2
    print(locals())
    print(globals())    
func()
#前者输出局部变量，后者输出全局变量

2、迭代器/生成器相关：range()、iter()、next()

　　range(n)：可迭代对象，可用于for循环得到0-n间的整数，包括0，不包括n

print(range(10))             #结果为：range(0,10)
for i in range(10):
    print(i)                 #结果为：0 1 2 3 4 5 6 7 8 9

　　iter():将可迭代对象转变为迭代器，等价于：可迭代对象.__iter__()

from collections import Iterable
from collections import  Iterator
lst=[1,2,3,4,5]
print(isinstance(lst,Iterable))                  #输出结果：True---是否可迭代对象
print(isinstance(lst.__iter__(),Iterator))       #输出结果：True---是否迭代器
print(isinstance(iter(lst),Iterator))            #输出结果：True---是否迭代器

　　next():返回迭代器的下一个值。next（迭代器）等价于迭代器.__next__()

#例1：
k=iter([1,2,3,4])
print(k.__next__())                             #输出结果为：1
print(next(k))                                  #输出结果为：2
#例2：
k=iter([1,2,3,4])
while True:
    try:
        print(next(k))
    except StopIteration: #超出迭代器的层数就退出循环
        break

3、字符串类型python代码执行相关：eval()、exec()、compile()

　　eval():执行字符串表达式，并返回表达式的值

print(eval('2*2'))                             #输出结果：4
x=3
print(eval('7*x'))                             #输出结果：21

　　exec():执行字符串代码，无返回值

4、内置函数filter()和map()

　　filter()函数：用于过滤序列，将不符合条件的序列过滤，返回符合条件的迭代器。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

def func(n):
    if n%2 == 0:
        return True
lst = [1,2,3,4,5,6,7]
ret = filter(func,lst)
print(list(ret))                              #输出结果为：[2,4,6]

　　map()函数： 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表的迭代器。

lst=[1,2,3,4]
def func（n）：
    return n**2
ret=map(func,lst)
print(list(ret)                              #输出结果为：[1,4,9,16]

5、输入和输出函数：input()、print()

　　print()函数：在py2中是个关键字，语法为：print(*objects, sep=' ', end='\n', file=sys.stdout)。objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。

sep -- 用来间隔多个对象，默认值是一个空格。end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。file -- 要写入的文件对象，默认是输出到屏幕，如果设置为文件句柄，输出到文件，如下实例：

f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)

#进度条实例
import time
import sys
for i in range(0,101,2):
     time.sleep(0.1)
     char_num = i//2      #打印多少个*
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', file=sys.stdout,flush=True )

6、zip（）函数：

　　语法为：zip（iterable,iterable...），将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表迭代器。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

l1 = (12,3,4,5,6,7)
l2 = ('a','b','c','d')
l3 = [9,8,7]
ret = zip(l1,l2,l3)
print(list(ret))                                  #输出结果为：[(12, 'a', 9), (3, 'b', 8), (4, 'c', 7)]

7、sorted（）函数：

　　sort（）与sorted（）的区别：sort是应用在list上方法，对list进行排序，并将改变原有的列表；而sorted（）是对可迭代对象进行排序，不改变原有的可迭代对象，语法如下：

sorted（iterable，key=...，reverse=...），key接收一个函数，按照函数进行排序，reverse为排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

#实例1：
l = [1,34,3,-5864,5,-1236,7]
print(sorted(l,reverse=True))                    #输出结果为：[34, 7, 5, 3, 1, -1236, -5864]
print(sorted(l,key=abs))                         #输出结果为：[1, 3, 5, 7, 34, -1236, -5864]
#实例2：
l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len))                         #输出结果为：[(7,), [1, 2], '123', [3, 4, 5, 6]]

 

二、匿名函数　　

　　目前在python语言中常见的一句话代码有：三元运算、各种表达式（如，列表表达式和生成器表达式）及匿名函数，也称为lambda表达式。

#普通函数
def calc(n):
    return n**n
print(calc(10))
 
#匿名函数
calc = lambda n:n**n
print(calc(10))

　　从上实例可以看出匿名函数的调用方式和普通函数一样，通过传参实现函数的调用，其格式可以总结为：函数名=lambda 参数1，参数2...：返回值；另一方面匿名函数可以实现真正的匿名。主要的表现在和其他功能函数合作的时候，如下例：

#实例1：
dic={'k1':10,'k2':100,'k3':30}
print(max(dic))                                           #找出字典中最大的key值
print(max(dic,key=lambda k:dic[k]))                       #找出字典中valu最大对应的key值

#实例2：
ret=map(lambda n:n**2,[1,2,3,4])
print(list(ret))                                          #输出结果为：[1, 4, 9, 16]

#实例3：
ret=filter(lambda n:n>10,[1,12,5,11,15])
print(list(ret))                                          #输出结果为：[12, 11, 15]

面试真题：

（1）现有两个元组(('a'),('b')),(('c'),('d'))，请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

#匿名函数形式：
l1=(('a'),('b'))
l2=(('c'),('d'))
ret=map(lambda n:{n[0]:n[1]},zip(l1,l2))
print(list(ret))
#列表表达式形式：
l1=(('a'),('b'))
l2=(('c'),('d'))
print([{n[0]:n[1]} for n in zip(l1,l2)])

（2）下面程序输出的结果是：24

d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)
x = t(x)
x = d(x)
print x

（3）以下代码的输出是什么？请给出答案并解释。

def multipliers():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
#解释：
　　函数返回值为一个列表表达式，经过4次循环结果为包含四个lambda函数的列表，由于函数未被调用，循环中的i值未被写入函数，经过多次替代，循环结束后i值为3，故结果为：6,6,6,6

　　请修改multipliers的定义来产生期望的结果（0,2,4,6）。

def multipliers():
    return （lambda x:i*x for i in range(4)）         #返回一个生成器表达式
print([m(2) for m in multipliers()])