day7_重要的内置函数(filter、map、zip、sorted、enumerate、reduce等)

filter：filter()函数接收两个参数，第一个是function or None，第二个是iterable，filter就是挨个把后面的元素传入到前面的函数，filter帮你循环调用这个函数，把可迭代对象里非True的过滤掉

例1：
def odd(x):
    return x % 2  # 返回所有的奇数

res = list(filter(odd, range(10)))
print(res)  # 打印出[1, 3, 5, 7, 9]

例2：
res = list(filter(None, [1, False, 'hello', 0]))
print(res)  # 打印出[1, 'hello']

map：map()函数接收两个参数，一个是函数，一个是可迭代对象，map是替你循环调用这个函数，把这个函数运算完的结果返回来，并把结果作为新的Iterator返回
例1：
def kua(name):
        return name + '你好'

names = ['光远', '大磊', '老杨']
res = map(kua, names)
print(list(res))  # 打印出['光远你好', '大磊你好', '老杨你好']

例2：
利用map()函数，把用户输入的不规则的英文名字，变为首字母大写，其他小写的规范名字，输入：['adam','LISA','barT']，输出：['Adam','Lisa','Bart']
def normalize(name):
    name = name[0].upper() + name[1:].lower()
    return name

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

zip：zip()函数来可以把可迭代对象合并，并创建一个元组对的列表，若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同
例1：
a1 = ['姓名', '年龄', '电话']
a2 = ('小黑', 18, 110)
print(list(zip(a1, a2)))  # 打印出[('姓名', '小黑'), ('年龄', 18), ('电话', 110)]

例2：
b1 = ['a', 'b', 'c', 'd', 'e']
b2 = [97, 98, 99]
for k, v in zip(b1, b2):  # b1, b2是可迭代对象，zip里不限制个数
       print('%s:%s' % (k, v)) # 打印出a:97 b:98 c:99，换行表示

sorted：sorted()函数返回一个新列表，该列表按升序包含iterable中的所有项，第一个参数是传一个可迭代对象，第二个参数传入key，按照某种规则进行排序，一般是key=函数名
例1：假设用一组tuple表示学生名字和成绩：L = [('Bob',75), ('Adam',92), ('Bart',66), ('Lisa',88)]，请用sorted()对上述列表分别按名字排序
lis = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
     return t[0]

print('sorted by name:')
print(sorted(lis, key=by_name))

例2：假设用一组tuple表示学生名字和成绩：L = [('Bob',75),('Adam',92),('Bart',66),('Lisa',88)]，请用sorted()对上述列表分别按成绩从高到低排序
lis = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_score(t):
     return t[1]

print('sorted by score:')
print(sorted(lis, key=by_score, reverse=True))

enumerate：enumerate()可以传入一个list、元组、字符串、字典，想要在for循环中同时迭代索引和元素本身，可用python内置的enumerate函数
for i, j in enumerate([1, 2, 3]):  # list
      print(i, j)
for m, n in enumerate('abc'):  # 字符串
      print(m, n)
for x, y in enumerate((1, 2, 3)):  # 元组
      print(x, y)
for k, v in enumerate({'a': 'aaa', 'b': 'bbb'}):  # 字典打印出key
      print(k, v)

reduce：reduce() 函数会对参数序列中元素进行累积，这个函数必须接收两个参数
例1：
from functools import reduce
def calc(a, b):
      return a * b

res = reduce(calc, [2, 3, 5])
print(res)

from collections import Iterable
print(isinstance('abc', Iterable))  # 打印出True
print(isinstance('nba', str))  # 通过collections模块的Iterable类型判断一个对象是否是可迭代对象，返回True或False
print(all([1, 2, 4, 7]))  # 判断可迭代对象里的值是否都为真，返回True
print(any([1, 2, 4, 7]))  # 判断可迭代对象里是否有一个值为真，返回True
print(bin(10))  # 十进制转成二进制，打印出0b1010，加上.replace('0b','')，打印1010
print(bin(10).replace('0b', ''))  # 十进制转成二进制
print(bool('s'))  # 把一个对象转成布尔类型，传入值非空即真

def my_type(var):
    if type(var) == list:
        print('此类型是list')
    elif type(var) == dict:
        print('此类型是字典')
    elif type(var) == int:
        print('此类型是整型的')
    elif type(var) == str:
        print('此类型是字符串')

print(dir(my_type))  # 打印出传入对象的可调用方法
eval()  # 执行python代码，只能执行简单的，定义数据类型和运算
print(exec('def a():print("哈哈")'))  # 执行复杂的python代码，调用函数打印出哈哈
print(max([1, 2, 3]))  # 取最大值
print(sum([1, 2, 3]))  # 求和
print(round(1.234, 2))  # 取几位小数，四舍五入