介绍几个Python内置函数

　　1：lambda：匿名函数

　　用法：用lambda创建函数，一般只是把函数赋值给变量，通过这个变量加括号执行lambda并获取结果，并不是得语句将函数赋值给变量。匿名是说在内存空间中只有函数内存地址没有函数名。

　　语法：lambda arg1,arg2,......:expression

　　声明函数 参数 表达式

　　1：支持多个函数 2：支持if/else语句

　　3：如果表达式为判别式，返回True或False

　　4：多层赋值函数，在多层嵌套函数里，先赋值给最外层。lambda也是一样的

　　5：lambda执行的功能有限

　　如果需要用函数实现简单的功能，lambda表达式就可以替代def语句形式：

　　def foo(x):

　　return x ** 2

　　print(foo(2)) # 4

　　l = lambda x: x ** 2

　　print(l(3)) # 9

　　print((lambda x: x ** 2)(3)) # 9

　　l = (lambda x: (lambda y: x < y))

　　print(l) # at 0x00FA4B28>

　　l1 = l(10) # 基准值 x:10

　　print(l1) # .. at 0x00C26738>

　　print(l1(5)) # False

　　print(l1(20)) # True

　　优化：

　　print((lambda x: (lambda y: x < y))(10)(5)) # False

　　print((lambda x: (lambda y: x < y))(10)(20)) # True

　　** 2：map：映射函数**

　　语法：map(func，*iterables)

　　# func: 可执行的函数

　　# iterables：迭代器，可迭代的序列

　　导入：from collections import Iterable，在Python3.9后就不需要导入了

　　def f2(x):

　　return x ** 2

　　map_obj = map(f2, range(1, 5))

　　print(map_obj) #

　　print(isinstance(map_obj, Iterable)) # True

　　print(list(map_obj)) # [1, 4, 9, 16]

　　1：map将第二个参数的值交给第一个参数去计算，并将结果收集返回一个map对象(其本质是个可迭代对象)，数据需要显式的通过list强转或for循环取值

　　2：map也支持多个序列同时执行函数：print(list(map(lambda x, y: x ** y, [2, 3, 4], [3, 2, 2]))) # [8, 9, 16]

　　上例，map函数将两个列表元素根据索引——映射为key:value的格式传递给lambda的x，y参数，计算后返回结果。

　　3：map函数将多个序列内的元素以映射的方式交给函数执行，且无法映射的将会被丢弃

　　#用map来处理列表,把列表中所有人都变成xx_666，如张开_666,

　　#name = ["张开", "李开", "王开", "赵开"]

　　name = ["张开", "李开", "王开", "赵开"]

　　print(list(map(lambda x: x + '_666', name)))

　　"""

　　使用map来处理列表，将列表中每个人的名字都变成以xx_666，如张开_666

　　tmp_list = [{'name': '张开'}, {'name': '李开'}, {'name': '王开'}, {'name': '赵开'}]

　　"""

　　tmp_list = [{'name': '张开'}, {'name': '李开'}, {'name': '王开'}, {'name': '赵开'}]

　　print(list(map(lambda x: x['name'] + '_666', tmp_list)))

　　3:zip:拉链函数

　　zip函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。

　　语法：

　　zip(iterables,iterables2,...iterablesn)

　　# iterables：可迭代对象

　　# 显示转化为列表的形式

　　l1=[1,2,3]

　　l2=["shimmer","winter","winner"]

　　zip_obj=zip(l1,l2)

　　print(list(zip_obj))

　　# 显示转化为字典的形式

　　l3=["大商股份","登记股份","贷款股份"]

　　tmp_list=[]

　　for l in (l1,l2):

　　tmp_list.append(dict(zip(l3,l)))

　　print(tmp_list)

　　1：如果各个可迭代对象的元素个数不一致，则返回的对象长度与最短的可迭代对象相同

　　2：zip将两个可迭代对象中的元素按照索引进行映射为元组，如果显式转换为列表，结果就是列表套元组的形式;如果显式转换为字典，则结果就是字典。

　　3：如果显式转化为列表，结果就是列表套元祖的形式

　　title = ["股票名称", "股票代码", "最新价"]

　　value1 = ["顺威股份", 2676, 3.69]

　　value2 = ["嘉泽新能", 601619, 4.91]

　　value3 = ["东方园林", 2310, 5.57]

　　print(list(zip(title, value1)))

　　print(list(zip(title, value1, value2)))

　　print(list(zip(title, value1, value2, value3)))

　　"""

　　[('股票名称', '顺威股份'), ('股票代码', 2676), ('最新价', 3.69)]

　　[('股票名称', '顺威股份', '嘉泽新能'), ('股票代码', 2676, 601619), ('最新价', 3.69, 4.91)]

　　[('股票名称', '顺威股份', '嘉泽新能', '东方园林'), ('股票代码', 2676, 601619, 2310), ('最新价', 3.69, 4.91, 5.57)]

　　"""

　　4：filter：过滤函数

　　filter函数根据条件过滤序列，将符合条件的元素返回。

　　语法：

　　filter(func, *iterables)

　　func: 可执行的函数

　　iterables：可迭代对象，可迭代的序列

　　用filter来处理,得到股票价格大于20的股票名字

　　shares={

　　‘IBM’:36.6,

　　‘Lenovo’:23.2,

　　‘oldboy’:21.2,

　　‘ocean’:10.2,

　　}

　　shares={

　　'IBM':36.6,

　　'Lenovo':23.2,

　　'oldboy':21.2,

　　'ocean':10.2,

　　}

　　m=filter(lambda key:shares[key]> 20,shares) #匿名函数的用法，题目一有详细注释

　　#filter函数的用法和map()函数类似，但filter返还的是key值。参考题目一

　　print(list(m))

　　---->['IBM', 'Lenovo', 'oldboy']

　　用filter过滤出，单价大于100的股票有哪些

　　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}

　　]

　　m=filter(lambda k:k['price'] > 100 ,portfolio)

　　print(list(m))

　　----->[{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]

　　1：filter函数中的第一个参数为None的话，则将为真的元素返回，如果返回的是不可调用对象的话，会报错。

　　2：filter函数根据条件过滤序列，将符合条件元素返回

　　3：filter也需要强装换才能返回数据

　　4：元素键名相同时：filter(lambda x:x[键名]条件，字典名)

　　5：键名不同时：filter(lambda k:字典名[k]条件，字典名)

　　5：reduce：累积函数

　　注意：Python3中 reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：需要先导入：from functools import reduce

　　reduce函数语法如下：

　　reduce(func, sequence, initializer)

　　func: function

　　sequence: 序列

　　initializer： 初始值，可选参数

　　1：如果序列为空，则将initializer值返回。

　　6：其他内置函数:

　　1:max/min

　　print(max(['b', 'c', 'e'])) # e

　　print(min(['b', 'c', 'e'])) # b

　　print(max([1, 'b', 3, 5, 'd'])) # TypeError: '>' not supported between instances of 'str' and 'int'

　　max/min返回序列的最大值和最小值，但要求是序列中的数据类型必须一致，不然无法比较

　　2:range

　　from collections import Iterable

　　res = range(3)

　　print(res) # range(0, 3)

　　print(isinstance(res, Iterable)) # True

　　print(list(res)) # [0, 1, 2]

　　在Python3中，range返回的是一个可迭代对象，需要显式的调用其中的元素。

　　3:chr/ord

　　print(chr(97)) # a

　　print(ord('a')) # 97

　　print(chr(1000)) # Ϩ

　　print(chr(1114111)) # 􏿿

　　print(chr(1114112)) # ValueError: chr() arg not in range(0x110000)

　　一般，我们通常使用chr和ord函数查看range(256)范围内整数对应的字符。但chr函数也能返回基于Unicode16位编码方式的整数对应的字符，它的范围是0~1114111，超过此范围就报错。

　　常用chr转换对应数字为对应英文字符，这个还是比较常用的：小写a-z为数字：97-122，大写A-Z为数字：65-90

　　4：进制转换

　　bin函数返回十进制的二进制表示;oct函数返回十进制的八进制表示;hex函数返回十进制的二进制。

　　print("10-->2", bin(20)) # 0b10100

　　print("10-->8", oct(20)) # 0o24

　　print("10-->16", hex(20)) # 0x14

　　如果八进制转十六进制，或者十六进制转二进制该怎么办

　　print('2-->8: ', oct(int('0b1010', 2))) # 2-10-8

　　print('2-->10:', int('0b1010', 2)) # 2-10

　　print('2-->16:', hex(int('0b1010', 2))) # 2-10-16

　　print('8-->2:', bin(int('0o12', 8))) # 8-10-2

　　print('8-->10:', int('0o12', 8)) # 8-10

　　print('8-->16:', hex(int('0o12', 8))) # 8-10-16

　　print('10-->2', bin(10)) # 10-2

　　print('10-->8', oct(10)) # 10-2

　　print('10-->16', hex(10)) # 10-16

　　print('16-->2:', bin(int('0xa', 16))) # 16-10-2

　　print('16-->8:', oct(int('0xa', 16))) # 16-10-8

　　print('16-->10:', int('0xa', 16)) # 16-10

　　"""

　　2-->8: 0o12

　　2-->10: 10

　　2-->16: 0xa

　　8-->2: 0b1010

　　8-->10: 10

　　8-->16: 0xa

　　10-->2 0b1010

　　10-->8 0o12

　　10-->16 0xa

　　16-->2: 0b1010

　　16-->8: 0o12

　　16-->10: 10

　　"""

　　10进制转别的进制直接使用对应的函数。而其他的进制转换都要先将本进制转为10进制，再通过各自进制的方法转换这个10进制数字就可以了。而需要注意的是int函数在将别的进制转换为10进制时，第一个参数要以字符串的形式传参。

　　5：dir

　　def foo():

　　pass

　　print(dir())

　　print(dir(foo))

　　"""

　　['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'foo']

　　['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

　　"""

　　当dir函数不指定参数的时候，返回当前作用域的变量及属性，而当指定参数的时候，则返回指定参数的属性。

　　6：globals/locals

　　def foo():

　　x, y = 2, 3

　　print(locals())

　　print(globals())

　　foo()

　　print(locals())

　　print(globals())

　　"""

　　{'y': 3, 'x': 2}

　　{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000027355A6B518>, '__spec__': None, '__annotations__': {}, '__builtins__': , '__file__': 'D:/tmp/test.py', '__cached__': None, 'foo': }

　　"""

　　locals函数一般用于局部作用域内，以字典的形式返回局部变量。而globals无论在局部还是全局，都以字典的形式返回当前位置的全局变量。如果locals用在全局，则跟globals返回的内容一致。

　　7：repr/str

　　print(repr('abc')) # 'abc'

　　print(str('abc')) # abc

　　repr函数将对象返回字符串的形式，类似str函数，但是repr返回的对象更友好与解释器(更加规范，返回的更多信息，倾向于解释器)，而str配合print返回的结果对用户更友好(提高用户的可读性，倾向于用户)。

　　8：sorted/list.sort

　　sorted函数将可迭代对象内的元素以升序的形式排序，并将排序结果以一个新列表的形式返回，相当于完全拷贝了一份原列表，然后对副本进行排序。

　　而sort只是列表自带的排序方法，并且是原地排序，即在原列表上进行排序。

　　这两个排序各有优势，sorted比list.sort更为强大，适用范围更广泛。在实际应用中，如果需要保留原列表，则采用sorted函数排序，否则可以选择list.sort方法，因为list.sort无需复制原列表，在效率和内存占用上更有优势。

　　"""

　　将下面的列表内的元素以age升序排序：

　　tmp_list = [

　　{'name': '张开', 'age': 18}, {'name': '李开', 'age': 8},

　　{'name': '王开', 'age': 32}, {'name': '赵开', 'age': 25}

　　]

　　"""

　　tmp_list = [

　　{'name': '张开', 'age': 18}, {'name': '李开', 'age': 8},

　　{'name': '王开', 'age': 32}, {'name': '赵开', 'age': 25}

　　]大连人流医院 http://www.84211111.cn/

　　#1：tmp_list.sort(key=lambda x: x['age'], reverse=False)#这条语句跟下面那条语句都可以得到题目想要的结果

　　tmp_list.sort(key=lambda x:x.get('age'),reverse=False)

　　print(tmp_list)

　　l1 = [2, 3, 1, 5, 4, 9]

　　print(id(l1)) # 2186440903304

　　s1 = sorted(l1) # 默认是升序排序

　　s2 = sorted(l1, reverse=True) # reverse为True时，降序排序

　　print(s1, id(s1)) # [1, 2, 3, 4, 5, 9] 2186440801672

　　print(s2, id(s2)) # [9, 5, 4, 3, 2, 1] 2186439007176

　　l2 = [4, 8, 3, 5, 7, 6]

　　print(id(l2)) # 2046115172296

　　l2.sort()

　　print(l2, id(l2)) # [3, 4, 5, 6, 7, 8] 2046115172296

　　l2.sort(reverse=True) # reverse为True时，降序排序

　　print(l2, id(l2)) # [8, 7, 6, 5, 4, 3] 2046115172296

　　9：round

　　round函数默认返回浮点数的四舍五入后的整数值，而指定ndigits参数，则返回四舍五入后的浮点类型的数值，小数位的位数取决于ndigits的参数值。

　　from math import pi

　　print(pi) # 3.141592653589793

　　print(round(pi)) # 3

　　print(round(pi, 3)) # 3.142

　　记得有一次老师出题，我看了前半部分没看后半部分，老师要求不保留小数，我看到前面给出来3.14，然后我就给他输出来3.14，结果后半部分说请给我输出无小数位的数，不看题的我把自己给整笑了，都不知道自己怎么看的题，就是下面那题

　　有派3.14 如何去掉小数位? 请用内置函数实现，注意不能使用切片

　　print(round(3.14))

　　10：enumerate

　　for number, value in enumerate(range(6)): # # 传递一个可迭代对象，start参数默认为0

　　print(number, "\t",value)

　　"""

　　number value

　　0 0

　　1 1

　　2 2

　　3 3

　　4 4

　　5 5

　　"""

　　for number, value in enumerate(range(6), start=10): # # 传递一个可迭代对象，start参数默认为0

　　print(number, "\t",value)

　　"""

　　number value

　　1 0

　　2 1

　　3 2

　　4 3

　　5 4

　　6 5

　　"""

　　enumerate(iterable, start=0)函数接收两个参数，iterable参数接收一个可迭代对象，而start参数则是指定在循环中，为每个元素设置序号的起始位置。start参数(默认为0)可以指定。一般较多的用在for循环中。

　　一般返回的是索引跟值