#自定义map函数

 def map_test(func, list):

     res = []

     for item in list:

         res.append(func(item))

     return res

 def add_one(x):

     return x + 1

 a = [1, 2, 3]

 print(map_test(add_one, a))

 print(map_test(lambda x:x + 1, a))  #终极版本

 #python中的内置函数map(),功能同上

 print('python的内置函数map()', list(map(lambda x:x + 1, a)))

 #map(参数1：功能函数（命名函数或者是匿名函数，参数2：可迭代对象（列表，字符串...））)

 #python2中map()函数处理的结果是一个列表，而python3中处理的结果是一个可迭代对象

 #自定义filter函数

 def filter_test(func, list):

     res = []

     for item in list:

         if func(item):

             res.append(item)

     return res

 def bigger5(x):

     if x > 5:

         res = True

     else:

         res = False

     return res

 a = [1, 2, 3, 10, 15, 6]

 print(filter_test(bigger5, a))

 #python内置函数filt(),功能同上

 print(list(filter(bigger5, a)))

 #filter(参数1：功能函数（命名函数或者是匿名函数，参数2：可迭代对象（列表，字符串...））)

 #python2中filter()函数处理的结果是一个列表，而python3中处理的结果是一个可迭代对象

 #自定义reduce函数

 def reduce_test(func, list, init = None):

     if init is None:

         res = list.pop(0)

     else:

         res = init

     for item in list:

         res = func(res, item)

     return res

 a = [1, 2, 3]

 print(reduce_test(lambda x, y:x + y, a))

 #python内置函数reduce()

 from functools import reduce

 a = [1, 2, 3]

 print(reduce(lambda x, y:x + y , a))  #

 print(reduce(lambda x, y:x + y , a, 2))  #

 #reduce(参数1：功能函数（命名函数或者是匿名函数），参数2：可迭代对象（列表，字符串...），参数3，初始值（可选参数）)

 #返回是一个值

 # ==========abs==========绝对值

 print(abs(-1))  #

 # ==========all==========可迭代对象的每个元素的布尔操作都是True时返回True，若传入的可迭代对象是空则返回True

 print(all(['', 1, 's']))  # False

 # ==========any==========可迭代对象的每个元素的布尔操作中有一个是True时就返回True，若传入的可迭代对象是空则返回True

 print(any(['', 5, '']))  # Ture

 # ==========bin==========将十进制数转成二进制数

 print(bin(3))  # 0b11

 # ==========hex==========将十进制数转成十六进制数

 print(hex(10))  # 0xa

 # ==========oct==========将十进制数转成八进制数

 print(oct(8))  # 0o10

 # ==========bool==========布尔值操作: 空 0 None 布尔操作为False

 print(bool([]))  # False

 # ==========bytes==========编码 将传入的字符串用某种编码方式转换成二进制

 print(bytes('陈', encoding='utf-8'))  # b'\xe9\x99\x88'

 print(bytes('陈', encoding='utf-8').decode('utf-8'))  # 陈  # 译码 译码与编码应采用一样的

 # ==========chr==========将ASCII码转成对应字符

 print(chr(97))  # a

 # ==========ord=========将字符转成对应的ASCII码值

 print(ord('a'))  #

 # ==========dir==========打印某种对象里面的所有属性

 print(dir(all))

 # ==========divmod==========参数1除以参数2 返回一个元组（商，余数）

 print(divmod(10, 3))  # (3, 1)

 # ==========eval==========

 dic = {'name': 'chen'}

 dic_str = str(dic)

 # ===================================功能1：提取成传入的字符串中的数据类型

 print(dic_str)  # '{'name': 'chen'}'

 print(type(dic_str))  # <class 'str'>

 print(eval(dic_str))  # {'name': 'chen'}

 print(type(eval(dic_str)))  # <class 'dict'>

 # ===================================功能2：计算字符串中的数学运算

 s = '1 + 2 * 1'

 print(eval(s))  #

 # ==========hash==========hash运算

 print(hash('chen'))  # -1076846465005340399

 print(hash('chenyuanyuan'))  # -8978753568388561982  #hash()---->hash运算

 # ==========help==========函数功能解释

 print(help(all))

 # ==========isinstance==========判断某个对象是否是某种数据类型的实例对象

 print(isinstance('', str))  # True

 # ==========globals、locals==========全局变量、局部变量

 name = 'chen'

 def test():

     age = 18

     print(globals())  # 打印所有的全局变量，包括name

     print(locals())  # {'age': 18} #打印所有的局部变量

 test()

 # ==========min、max==========最小值、最大值

 dic = {'chen': 100, 'wang': 200, 'li': 500, 'do': 600}

 # ============一个可迭代参数

 print(min(['a01', 'b10', 'c1']))  # a01 遍历出每个元素，比较它们的的第一位的ASCII码值，找到最小后就停止比较

 # print(min(['a01', 'b10', 'c1', 30])) #报错 不同数据类型无法比较

 print(min(dic))  # chen

 print(max(dic))  # wang

 print(min(dic.values()))  #

 print(max(dic.values()))  #

 print(max(zip(dic.values(), dic.keys())))  # (600, 'do') #max与zip结合找出value值最大的那一组

 # ============两个参数

 print(min(dic, key=lambda k: dic[k]))  # chen

 print(max(dic, key=lambda k: dic[k]))  # do

 # ==========zip==========拉链操作，将多个可迭代对象(列表，元组，字符串)对应元素组成一个元组，多余元素自动去掉，返回可迭代对象

 print(list(zip('abc', 'def', 'ghihhhhh')))  # [('a', 'd', 'g'), ('b', 'e', 'h'), ('c', 'f', 'i')]

 print(list(zip(dic.keys(), dic.values())))  # [('chen', 100), ('wang', 200), ('li', 500), ('do', 600)]

 # ==========pow==========参数1的参数2次方，结果对参数3进行取余操作

 print(pow(2, 3))  #

 print(pow(2, 3, 1))  #

 # ==========reversed==========反转可迭代对象中元素的排列顺序，返回迭代器

 a = [1, 2, 3]

 print(list(reversed(a)))  # [3, 2, 1]

 # ==========round==========四舍五入取整

 print(round(2.66))  #

 # ==========set==========将其他数据类型转换成集合

 print(set('hello'))  # {'h', 'o', 'e', 'l'}

 # ==========slice==========切片：参数1-->起始索引，参数2-->结束索引，参数3-->步长

 a = 'ehllovihgh'

 s1 = slice(2, 6, 2)

 print(s1.start)  #

 print(s1.stop)  #

 print(s1.step)  #

 print(a[s1])  # lo

 # ==========sorted==========排序

 a = [1, 25, 2, 3]

 print(sorted(a)) #[1, 2, 3, 25]  #不同数据类型任然无法进行排序比较

 lists = [{'name': 'chen', 'age': 18}, {'name': 'wang', 'age': 25}, {'name': 'li', 'age': 9}]

 print(sorted(lists, key = lambda dic:dic['age']))

 #[{'name': 'li', 'age': 9}, {'name': 'chen', 'age': 18}, {'name': 'wang', 'age': 25}]

 info = {'liu': 100, 'li': 12200, 'chen': 100000}

 print(sorted(info.keys()))  #['chen', 'li', 'liu']  #比较key值

 print(sorted(info.values())) #[100, 12200, 100000]  #比较value值

 print(sorted(info, key = lambda key: info[key]))   #['liu', 'li', 'chen'] #比较value值，返回key值

 print(sorted(zip(info.values(), info.keys())))   #[(100, 'liu'), (12200, 'li'), (100000, 'chen')]

 # ==========type==========查看数据类型

 print(type('ll'))  # <class 'str'>

 # ==========sum==========求和

 print(sum([5, 2, 3])) #

 # ==========range==========范围

 for item in range(5):

     print(item)

 #

 #

 #

 #

 #

 for item in range(5, 7):

     print(item)

 #

 #

 # ==========__import__==========引入字符串类型的模块名

 m = __import__('...')

 m.函数名()