Python基础08 函数（3）高阶函数、匿名函数、常用内置函数

一、高阶函数

满足下列条件之一，即为高阶函数：
（1）函数接收的参数是一个函数名
（2）返回值中包含函数

def f1(func):
    func()
    return func

def f2():
    print('I am f1')

print(f1(f2))
'''
I am f1
<function f2 at 0x00000189807CE0D0>
'''

二、匿名函数

语法构造：lambda 形参：返回值

func = lambda x,y:(x-y,x*y)
print(func(5,2))    #(3, 10)

三、常用内置函数

1、map()、filter()、reduce()、sun()

（1）map() 将可迭代对象遍历，并传参给指定函数处理，一一映射，组成新的可迭代对象。

print(map(lambda x:x**2,range(3)))  #<map object at 0x0000020367DF9370>
print(list(map(lambda x:x**2,range(3))))    #[0, 1, 4]

（2）filter() 将可迭代对象遍历，并传参给指定函数处理，计算出bool值，为真的元素留下。

l = ['aa','ab','bb','ac']

print(list(filter(lambda x:x.startswith('a'),l)))
#['aa', 'ab', 'ac']

（3）reduce() 将可迭代对象遍历，并传参给指定函数处理，得到一个值。

from functools import reduce
l = [2,3,5,10]
#不指定初始值
print(reduce(lambda x,y:x+y,l))         #20

#指定初始值
print(reduce(lambda x,y:x+y,l,-2))      #18

(3)sum() 求和

print(sum(range(4)))    #6

2、abs()、divmod()、pow()

（1）abs() 计算绝对值

print(abs(-4.2))    #4.2
print(abs(44))      #44

（2）divmod() 返回一个元组，(整除商,余数)

print(divmod(11,2)) #(5, 1)

（3）pow()

print(pow(2,3))     #8  相当于2**3
print(pow(2,4,3))   #1  相当于2**4%3

（4）round() 将数字四舍五入到给定的十进制精度。

print(round(3.5))       #4
print(round(5.5555,2))  #5.56

3、all()、any()

（1）all() 迭代对象所有元素为真，返回True。或者迭代对象为空，返回True。

print(all([1,2,0])) #False
print(all(''))      #True

（2）any() 迭代对象任何一个元素为真，返回True。或者迭代对象为空，返回False。

print(any([1,2,0])) #True
print(any(''))      #False

4、bin()、hex()、oct()

print(bin(10))  #10进制->2进制      0b1010
print(hex(12))  #10进制->16进制     0xc
print(oct(12))  #10进制->8进制      0o14

5、bool()、dict()、float()、frozenset() 、int()、list()、set()、str()、tuple()

（1）bool() 根据参数，返回为布尔类型

print(bool(None))   #False
print(bool(2))      #True

（2）dict() 根据参数，返回字典类型

print(dict(name='CRTao',age=18))    #{'name': 'CRTao', 'age': 18}

（3）float() 转换为浮点数

v = float('5.3') + float('1.1')
print(v)    #6.4

（4）frozenset() 返回一个不可变类型的集合

l = [1,2,2,3,4]
s = frozenset(l)
print(s)    #frozenset({1, 2, 3, 4})

（5）int() 转换为整型

n = 5.5
print(int(n))   #5

（6）list() 转化为列表

s = 'abc'
l = list(s)
print(l)    #['a', 'b', 'c']

（7）set() 转化为集合
（8）str() 转化为字符串（整体加引号）

l = [1, 2, 3]
s = str(l)
print(s, type(s))  # [1, 2, 3] <class 'str'>

（9）tuple 转化为元组

6、bytes() 、chr()、ord()

（1）bytes() 返回为字节形式

name='你好'
print(bytes(name,encoding='utf-8')) #b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(bytes(name,encoding='utf-8').decode('utf-8')) #你好

（2）chr() 根据数字返回Unicode字符；ord() 根据字符，返回Unicode对应的数字

print(chr(97))      #a
print(ord('a'))     #97

7、dir()、help()

（1）dir() 返回由对象或类的属性组成的目录列表

print(dir(float))

(2) help() 查看帮助

8、enumerate() 、range() 、reversed() 、slice()、sorted()、zip()

（1）enumerate() 返回一个枚举对象

l = ['aa','bb','cc']

# 不设置初始值
for i in enumerate(l):
    print(i)
'''
(0, 'aa')
(1, 'bb')
(2, 'cc')
'''

#设置初始值
for i,j in enumerate(l,2):
    print(i,j)
'''
2 aa
3 bb
4 cc
'''

（2）range() 返回一个迭代器，例：
range(0,12,3) 表示取数字0~12，且不包含12，步长为3。其中起始值为0可以省略，步长为1可以省略。

for i in range(0,12,3):
    print(i,sep=';',end=';')    #0;3;6;9;

（3）reversed() 将序列反转

l = [1, 2, 3, 4]
s = 'abc'
print(list(reversed(l)))  # [4, 3, 2, 1]
print(list(reversed(s)))  # ['c', 'b', 'a']

（4）slice() 切片

s = 'hello world'
sl = slice(3, 10, 2)
print(s[sl])  # l ol
print(sl.start, sl.stop, sl.step)  # 3 10 2

（5）sorted() 排序

l = ('a','g','c','b')
print(sorted(l,reverse=True))   #['g', 'c', 'b', 'a']
dic = [
    {'name': 'CRTao', 'age': 18},
    {'name': 'DRTao', 'age': 81},
    {'name': 'FRTao', 'age': 8}
]

s = sorted(dic,key=lambda li:li['age'])
print(s)    #[{'name': 'FRTao', 'age': 8}, {'name': 'CRTao', 'age': 18}, {'name': 'DRTao', 'age': 81}]

（6）zip() 将两个迭代对象，按元素顺序，合成一个迭代对象

dic = {
    'CRTao': 18,
    'DRTao': 81,
    'FRTao': 8
}
v = zip(dic.keys(),dic.values())
print(list(v))  #[('CRTao', 18), ('DRTao', 81), ('FRTao', 8)]

9、eval()

将字符串的引号去掉，取其中的值

s = '5+6-1'
print(eval(s))  #10

10、globals() 、locals()、vars()

（1）globals() 返回包含当前作用域全局变量的字典。
（2）locals() 返回一个包含当前作用域局部变量的字典。
（3）vars() 如果没有参数，等同locals()l；有一个参数，则等同object.__dict__

11、hash()

返回哈希值
可hash的数据类型为不可变数据类型，不可hash的数据类型为可变数据类型

12、id() 、len()

（1）id() 返回对象的标识，这保证在同时存在的对象中是唯一的。(CPython使用对象的内存地址。)

a = 1
b = 'a'
print(id(a),id(b))  #140712786073248 1463940782768

（2）len() 返回长度

print(len('abc'))           #3
print(len(['aa','abc']))    #2

13、input()、print()

（1）input() 读取一个标准输入的字符串

age = input('请输入：')
print(age)
'''
请输入：18
18
'''

（2）print 打印
参数sep可以指定分隔符
参数end可以指定末尾添加字符串
花哨的打印效果：

n=5
print("\033[31;1m[producer]\033[0m is making baozi %s and %s" %(n,n+1) )

# \033: ASCII 转义字符的起始点。
# [: ANSI 控制码序列的起始标志。
# 31;1: ANSI 控制码，31 表示设置文本颜色为红色，1 表示加粗显示。
# m: ANSI 控制码序列的结束标志。
# \033[0m 用于重置文本样式。这样可以确保在指定的文本后，不会继续应用任何之前设置的文本样式。

14、isinstance()、issubclass()、type()

（1）isinstance() 判断是否为实例

print(isinstance(1,int))    #True

（2）issubclass() 判断是否为子类

class Foo:
    pass

class Bar(Foo):
    pass

print(issubclass(Bar, Foo)) # True

（3）type() 显示参数类型，type(obj)其实是查看obj是由哪个类实例化来的

msg = '11'
if type(msg) is str:
    msg = int(msg)
    res = msg + 1
    print(res)  # 12

15、iter()、next()

（1）iter() 转换为迭代器（有__next__方法的对象），作用同__iter__()方法

l = ['aa','bb']
ln = iter(l)
print(ln.__next__())    #aa
print(ln.__next__())    #bb

l = ["a","b","c","d"]

def test():
    return l.pop()

x=iter(test,"b")    # 此时不需要test为可迭代对象，可以不断调用test函数，直到遇到哨兵值“b”为止
print(x.__next__()) # d
print(x.__next__()) # c

（2）next() 取迭代对象的下一个元素，作用同__next__方法

16、max()、min()

（1）max() 取最大值；min() 取最小值
（2）比较顺序是先比较可迭代对象中各元素中的第一个元素；比较不出结果，再依次比较各元素中的下一个元素。

l = [(2,4),(2,3),(3,4)]
print(max(l))   #(3, 4)
print(min(l))   #(2, 3)

（3）可以加关键字key，指定比较方法。

dic = [
    {'name': 'CRTao', 'age': 18},
    {'name': 'DRTao', 'age': 81},
    {'name': 'FRTao', 'age': 8}
]
m = max(dic, key=lambda p: p['age'])
print(m)    #{'name': 'DRTao', 'age': 81}

17、open() 打开文件

详见 Python基础09 文件操作

18、__import__()

调用模块，比关键字import功能更强大，参数可以传递字符串