12

Python语言的高级特性

函数是编程（Functional Programming）

• 基于lambda演算的一种编程方式
  • 程序中只有函数
  • 函数可以作为参数，同样可以作为返回值
  • 纯函数式变成语言：LISP，Haskell
• Python函数式编程只是借鉴函数式编程的一些特点，可以理解成一般函数式一般Python
• 需要讲述
  • 高阶函数
  • 返回函数
  • 匿名函数
  • 装饰器
  • 偏函数

lambda表达式

• 函数：最大程度复用代码
  • 存在问题：如果函数很小，很短，则会造成啰嗦
  • 如果函数被调用次数少，则会造成浪费
  • 对于阅读者来说，造成阅读流程的被迫中断
• lambda表达式（匿名函数）：
  • 一个表达式，函数体相对简单
  • 不是一个代码块，仅仅是一个表达式
  • 可以有参数，有多个参数也可以，用逗号隔开

# lambda表达式的用法
# 1.以lamnda开头
# 2.紧跟一定的参数（有的话）
# 3.参数后用冒号和表达式主题隔开
# 4.只是一个表达式，所以没有return

# 计算一个数字的100倍数
stm = lambda X: 100 * X
print(stm(89))

stm2 = lambda x,y,z: x + y * 10 + z * 100
print(stm2(4,5,6))

高阶函数

• 把函数作为参数使用的函数，叫高阶函数

# 函数名称是变量
# 函数名称就是一个变量
# 既然函数名称是变量，则应该可以被当做参数传入另一个函数
'''
# 高阶函数举例
# funA是普通函数，返回一个传入数字的100倍数字
def funA(n):
    return n * 100
# 再写一个函数，把传入参数乘以300倍，利用高阶函数
def funB(n):
    # 最终是想返回300n
    return funA(n) * 3
print(funB(9))

# 写一个高阶函数
def funC(n,f):
	# 假定函数是把n扩大100倍
	return f(n) * 3
print(funC(9,funA))

系统高阶函数-map

• 原意就是映射，即把集合或者列表的元素，每一个元素都按照一定规则进行操作，生成一个新的列表或者集合
• map函数是系统提供的具有映射功能的函数，返回值是一个迭代对象

# 利用map
l1=[i for i in range(11)]
print(l1)
def mulTen(n):
	return n*10
l3 = map(mulTen, l1)

print(list(l3))

reduce

• 原意是归并，缩减
• 把一个可迭代对象最后归并成一个结果
• 对于函数参数要去：必须由两个参数，必须有返回结果
• reduce(函数，列表)
• reduce([1,2,3,4,5]) == f(f(f(f(1,2),3),4),5)
• reduce需要导入functools包

from functools import reduce
# 定义一个操作函数
# 加入操作做函数只是相加

def myAdd(x,y):
	return x * y
# 对于列表[1,2,3,4,5,6]执行myAdd的reduce操作
rst = reduce(myAdd,[1,2,3,4,5])
print(rst)

filter过滤函数

• 过滤函数：对一组数据进行过滤，符合条件的数据会生成一个新的列表并返回
• 跟map相比
  • 相同：都对列表的每一个元素逐一进行操作
  • 不同：
    • map会生成一个跟原来数据相对应的新队列
    • filter不一定，只要符合条件的才会进入新的数据集合
  • filter函数怎么写
    • 利用给定函数进行判断
    • 返回值一定是个布尔值
    • 调用格式：filter(f,data),f是过滤函数，data是数据

# filter案例
# 对于一个列表，对其进行过滤，偶数组成一个新列表
# 需要定义过滤函数
# 过滤函数要求有输入，返回布尔值
def isEven(a):
	return a % 2 == 0
l = [3,4,64,4322,6554,342,65,867]
rst = filter(isEven, l)
# 返回的filter内容是一个可迭代对象
print(list(rst))

高阶函数-排序sorted

• 把一个序列按照给定算法进行排序（升序）
• key：在排序前对每一个元素key函数运算，可以理解成按照key函数定义的逻辑进行排序
• python2和python3相差巨大

# 排序的案例

a = [-21,321,432242,-4322,21,43,-564,2334]
al = sorted(a)
print(al)

# 按照绝对值进行排序
# abs是求绝对值的意思
# 即按照绝对值的倒序排序
a1 = sorted(a, key=abs, reverse=True)
print(a1)

astr = ['dana', 'Danaa', 'jjc', 'wcx']
str1 = sorted(astr)
print(str1)

str2 = sorted(astr, key=str.lower)
print(str2)

返回函数

• 函数可以返回具体的值
• 也可以返回一个函数作为结果

# 定义一个普通函数
def myF(a):
	print('In myF')
	return None
a = myF(8)
print(a)	

# 函数作为返回值返回，被返回的函数在函数体内定义
def myF2():
	def myF3():
		print("In myF3")
		return 3
	return myF3
	
# 使用上面定义
# 调用myF2，返回一个函数myF3，赋值给f3
f3 = myF2()
print(f3())

def myF4( *args):
	def myF5():
		rst = 0
		for n in args:
			rst += n
		return rst
	return myF5
f5 = myF4(1,2,3,4,5,6,7)
print(f5())

闭包

• 当一个函数在内部定义函数，并且内部的函数应用外部函数的参数或者局部变量，当内部函数被当做返回值的时候，相关参数和变量保存在返回的函数中，这种结果，叫闭包
• 上面定义的myF4是一个标准闭包结构

# 闭包常见坑
def count():
	# 定义列表
	fs = []
	for i in range(1,4):
		def f():
			return i*i
		fs.append(f)
	return fs
f1,f2,f3 = count()
print(f1())

## 出现的问题：
- 造成上述状况的原因是，返回函数引用了变量i，i并非立即执行，而是等到三个函数都返回的时候才统一使用，此时i已经变成了3，最终调用的时候，都返回的是3*3
- 此问题描述成：返回闭包时，返回函数不能引用任何循环变量
- 解决方案：在创建一个函数，用该函数的参数绑定循环变量的当前值，无论该循环变量以后如何改变，已经绑定的函数参数值不再改变

def count1():
	def f(j):
		def g():
			return j*j
		return g
	fs =[]
	for i in range(1,4):
		fs.append(f(i))
	return fs
f1,f2,f3 = count1()
print(f1())
print(f2())
print(f3())

装饰器（Decrator）

• 在不改动函数代码的基础上无限制扩展函数功能的一种机制，本质上讲，装饰器是一个返回函数的高阶函数
• 装饰器的使用：使用@语法，即在每次要扩展的函数定义前使用@+函数名

import time
# 高阶函数，以函数作为参数
def printTime(f):
	def wrapper(*args, **kwargs):
		print("Time:", time.ctime())
		return f(*args, **kwargs)
	return wrapper
# 上面定义了装饰器，使用的时候需要用到@，此符号是python的语法糖
@printTime
def hello():
	print("Hello world")
hello()
# 装饰器的好处是，一点定义，则可以装饰任意函数
# 一旦被其装饰，则把装饰器的功能直接添加到定义函数的功能上
# 上面对函数的装饰使用了系统定义的语法糖

hello =printTime(hello)
hello()

偏函数

• 参数固定的函数，相当于一个由特定参数的函数体
• functools.partial的作用是，把一个函数某些函数固定，返回一个新函数

#
i = int("100E", base=32)
print(i)

# 新建一个函数，此函数是默认输入的字符串是16进制数字
# 把次字符串返回十进制的数字

def int16(x, base=16):
	return int(x,base)
t = int16("12345")
print(t)



import functools
# 实现上面int16的功能
int16 = functools.partial(int, base=16)
print(int16("12345"))

zip

• 把两个可迭代内容生成一个可迭代的tuple元素类型组成的内容

l1 = [1,2,3,4,5,6,7]
l2 = [11,12,13,14,15,16]

z = zip(l1,l2)
print(tuple(z))

enumerate

• 跟zip功能比较像
• 对可迭代对象里的每一个元素，配上一个索引，然后索引和内容构成tuple类型

l1 = [1,2,3,4,5,6,7]
em = enumerate(l1)
l3 = [i for i in em]
print(l3)

collections模块

• namedtuple
  • tuple类型，是一个可命名的tuple
• deque
  • 比较方便的解决了频繁删除插入带来的效率问题
• counter
  • 统计字符串个数

# cellections
import collections
Point = collections.namedtuple("point",['x', 'y'])
p = Point(11,22)
print(p.x)
print(p[0])


Circle = collections.namedtuple("Circle", ['x', 'y', 'r'])
c = Circle(100,150,10)
print(c)

# deque
from collections import deque

q = deque(['a', 'b', 'c'])
print(q)
q.append('d')
print(q)
q.appendleft('x')
print(q)

# Counter
from collections import Counter
c = Counter('dghasjkdahduqahwfh')
print(c)

s = ['jjc', 'jjc', 'jjc', 'sdaa', 'wsd', 'wcx', 'wcx']
d = Counter(s)
print(d)