第四阶段 -- python核心特性：【函数式编程】

1. range的使用

1. range(stop)：默认从0开始，直到stop-1（包头不包尾）
2. range(start[,stop,step])：
   • step：默认是1；如果是负值，就是递减

for i in range(10,-1,-1):
	print(i,end=' ')

2. 偏函数 – partial

【菜鸟教程】：https://www.runoob.com/w3cnote/python-partial.html

1. 定义：用于对函数固定属性的函数。
2. 作用：把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

from functools import partial

str1 = '1010'
result = int(str1,2)
print(result)

# 重新定义一个函数--稍微简化了一点
def int2(n,base=2):
    return int(n,base)

result = int(str1)
print(result)

# 使用偏函数来完成类似的功能
int3 = partial(int, base=2)
print(type(int3))
print(int3(str1))

3. wraps函数

• 【关于解释器的博客】https://www.runoob.com/w3cnote/python-func-decorators.html
• 作用：functools.wraps 可以将原函数对象的指定属性复制给包装函数对象，默认有module，name，doc或者通过参数选择。

from functools import wraps

def log(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print('%s was calling'%func.__name__)
        return func(*args, **kwargs)
    return with_logging

@log
# test = log(test)
def test(x):
    """求x的值"""
    return x*x

print(test.__name__)
print(test.__doc__)

4. map函数

1. map(func, iterables)

from collections import Iterable,Iterator

list1 = [1,2,3]
list2 = [4,5,6,7]
def func1(x):
    return 2*x
def func2(x,y):
    return x+y

# 生成一个迭代器
# it1 = map(func,list1)
it1 = map(lambda x:x*2, list1)
print(isinstance(it1,Iterator))
for i in it1:
    print(i, end='/n')
    
print("------------------------------")

# it2 = map(func2,list1,list2)
it2 = map(lambda x,y:x+y, list1, list2)
for i in it2:
    print(i,end='\t')

5. reduce函数

• reduce() 函数会对参数序列中元素进行累积。
  函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

• 语法：reduce(function, iterable[, initializer])

  • function – 函数，有两个参数
  • iterable – 可迭代对象
  • initializer – 可选，初始参数

• 有一个存储了5个整数的列表，求列表中所有元素的和

from functools import reduce

list = [1,2,3,4]
result = reduce(lambda x,y:x+y, list)
print(result)

6. filter函数

• 语法：filter(function, iterable)

list1 = [1,2,3,0,10,0,25]
			###### 遍历列表中不为0的元素 ######
# it1 = filter(None, list1)
# for i in it1:
#     print(i, end=' ')
it1 = filter(lambda:x:x!=0, list1)
for i in it1:
    print(i, end=' ')

			###### 遍历列表中大于5的元素 ######
it2 = filter(lambda x:x>5, lis1)
for i in it2:
    print(i, end=' ')

7. 内置函数sorted()

1. list.sort()：无返回值，对源数据进行排序

2. sorted()：有返回值，返回排序备份

3. sorted(iterable[, cmp[, key[, reverse]]])

   • iterable：可迭代对象。
   • cmp：比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
   • key： 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
   • reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

4. sorted(iterable, key=None, reverse=False)

   list1 = [1,4,2,7,11,10]
   list2 = sorted(list1)
   print(list2)
   list3 = sorted(list1, reverse=True)
   print(list3)
   

   # key的用法
   # 正数从小到大，负数从大到小排序
   list1 = [1,0,-9,29,3,-10,-2,-5]
   list2 = sorted(list1, key=lambda x:(x<0, abs(x)))
   

   # 列表中自定义对象的排序
   class student():
   	def __init__(self,name.age):
           self.name = name
           self.age = age
   stu1 = Student('aa',19)
   stu2 = Student('bb',20)
   stu3 = Student('cc',18)
   
   list1 = [stu1, stu2, stu3]
   for i in list1:
       print(stu.name, stu.age)
       
   print('-----------------------------------')
   
   list2 = sorted(list1, key=lambda x:x.age)
   for stu in list2:
       print(stu.name,stu.age)