Python3 commonly used several built-in methods

max () / min ()

• Pass a parameter (iterable), returns the iterables largest element
  • Keyword default parameters can be provided, when the iterables empty, return the default value
• Passed a number of parameters, return the largest of these parameters parameters
  • A number of parameters must be the same type of
• Both methods can set the key keyword arguments (passed into the function)

"""
    max(iterable, *[, default=obj, key=func]) -> value
    max(arg1, arg2, *args, *[, key=func]) -> value
    
    With a single iterable argument, return its biggest item. The default keyword-only argument specifies an object to return if the provided iterable is empty.
    With two or more arguments, return the largest argument.
"""


res = max([1, 2, 3], default=0)
print(res)  # 3

# 传入了一个空的可迭代的对象参数, 返回默认值0
res = max([], default=0)
print(res)  # 0



lis = [1, 2, 3]


def func(num):
    return -num


# res = max(lis, key=func)
res = max(lis, key=lambda num: -num)
print(res)  # 1

"""
key参数接收的是一个函数对象
max函数会将lis里面的元素依次传入转换函数 
哪个元素经过转换函数得到的值最大, 就返回该元素
"""

filter () filter

• The first parameter (parameter), either func, either None, will not pass error
• The second parameter is iterables
• Returns a filter obj (iterator)
• filter () method filters out:
  • Boolean value of False element itself
  • After the function processing, returns the boolean value False element values

"""
    filter(function or None, iterable) --> filter object
    
    Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return the items that are true.
"""
    
    
"""
需要传入两个参数, 第一个是函数或者None, 第二个是可迭代对象
返回的是一个filter obj(迭代器)
如果第一个参数时None, 则返回的迭代器中只包含可迭代对象中为True的元素
如果第一参数是一个函数, 可迭代对象中元素传入该函数, 结果为True, 则filter方法返回的迭代器就会包含此元素
"""
lis = [0, 1, 2, 3]

filter_obj = filter(None, lis)
print(list(filter_obj))  # [1, 2, 3]


def func(num):
    if num > 1:
        return 0


filter_obj = filter(func, lis)
print(list(filter_obj))  # []

filter_obj = filter(lambda num: num > 1, lis)
print(list(filter_obj))  # [2, 3]

map () map

• The first argument must be a function
• You may pass behind the one or more parameters iterable
  • The number of iterations may be object parameters, and the number of arguments must be the same as
  • A plurality of iterations the number of elements may comprise inconsistent objects, places a minimum number of elements that prevail
• Returns a map obj (iterator)

"""
    map(func, *iterables) --> map object
    
    Make an iterator that computes the function using arguments from
    each of the iterables.  Stops when the shortest iterable is exhausted.    
"""
    
def func1(x):
    return x + 1


"""
参数1: 函数, 参数2:可迭代对象
1.可迭代对象的中的元素依次传入函数得到返回值res
2.调用map函数最终会得到一个迭代器对象iterator
3. 这个iterator就包含了res
"""
map_obj = map(func1, [1, 2, 3])
print(list(map_obj))  # [2, 3, 4]


def func2(x, y):
    return x + y


"""
传入的可迭代对象参数个数与函数所需要的参数个数是相等的
取值个数以最短的为准
"""
map_obj = map(func2, [1, 2, 3], [1, 2, 3, 4])
print(list(map_obj))  # [2, 4, 6]

sorted screening

• The first parameter is iterable
• The second parameter is the key, the third parameter is the reverse, these two parameters may not pass

"""
    sorted(iterable, key, reverse) --> list
    
    Return a new list containing all items from the iterable in ascending order.
    A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.
"""
lis = [3, 2, 4, 5, 1]

# 1.只传入可迭代对象参数
res = sorted(lis)
print(res)  # [1, 2, 3, 4, 5]


def func(x):
    return -x
"""
2.当传入函数时, 可迭代对象元素排序的依据是他们传入函数得到结果
注意: 还是对原来的元素进行排序, 而不是对元素传入函数得到的结果, 只是以这个结果为排序的依据
"""
res = sorted(lis, key=func)
print(res)  # [5, 4, 3, 2, 1]

reduce () decrease

• The first parameter is a function of
  • This function must be and only two parameters
• The second parameter is the sequence
• initial is the initial value can be used as the first element of the sequence
• This means that decreasing reduce the number of elements in the sequence until the sequence of only one element, the element returns

from functools import reduce

"""
    reduce(function, sequence[, initial]) -> value

    Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value.
    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5).  
    If initial is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty.
"""

lis = [1, 2, 3, 4, 5]
res1 = reduce(lambda x, y: x + y, lis)
print(res1)  # 15

res2 = reduce(lambda x, y: x + y, lis, 1)
print(res2)  # 16