python中常见的内置函数

• map

#自定义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

#自定义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

#自定义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))  #6
print(reduce(lambda x, y:x + y , a, 2))  #8
#reduce(参数1：功能函数（命名函数或者是匿名函数），参数2：可迭代对象（列表，字符串...），参数3，初始值（可选参数）)
#返回是一个值

①map():对可迭代对象中的每个元素都进行相同的处理，最后返回一个新的可迭代对象，python2中直接返回列表形式
②filter():对可迭代对象中的每个元素进行筛选，最后将符合条件的元素装进一个新的可迭代对象里，python2中直接返回列表形式
③reduce():对可迭代对象中的元素进行一个操作（如所有的值加起来），最后返回新数值

• 其他内置函数

# ==========abs==========绝对值
print(abs(-1))  # 1

# ==========all==========可迭代对象的每个元素的布尔操作都是True时返回True，若传入的可迭代对象是空则返回True
print(all(['', 1, 's']))  # False

# ==========any==========可迭代对象的每个元素的布尔操作中有一个是True时就返回True，若传入的可迭代对象是空则返回True
print(any(['', 5, '0']))  # 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'))  # 97

# ==========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))  # 3

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

# ==========help==========函数功能解释
print(help(all))

# ==========isinstance==========判断某个对象是否是某种数据类型的实例对象
print(isinstance('2', 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()))  # 100
print(max(dic.values()))  # 600
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))  # 8
print(pow(2, 3, 1))  # 0

# ==========reversed==========反转可迭代对象中元素的排列顺序，返回迭代器
a = [1, 2, 3]
print(list(reversed(a)))  # [3, 2, 1]

# ==========round==========四舍五入取整
print(round(2.66))  # 3

# ==========set==========将其他数据类型转换成集合
print(set('hello'))  # {'h', 'o', 'e', 'l'}

# ==========slice==========切片：参数1-->起始索引，参数2-->结束索引，参数3-->步长
a = 'ehllovihgh'
s1 = slice(2, 6, 2)
print(s1.start)  # 2
print(s1.stop)  # 6
print(s1.step)  # 2
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])) #10

# ==========range==========范围
for item in range(5):
    print(item)
# 0
# 1
# 2
# 3
# 4
for item in range(5, 7):
    print(item)
# 5
# 6

# ==========__import__==========引入字符串类型的模块名
m = __import__('...')
m.函数名()