11.高阶函数（匿名/*递归/函数式）对象编程基础

Posted 2020-10-05 简明现代魔法

高阶函数
匿名函数
匿名函数存在的情况：
内置函数
函数式编程
递归
函数式编程
面向对象的程序设计
类：
实例：
OOP
类的名称空间/对象的名称空间

高阶函数

匿名函数

lambda x:x+y #return x+y
定义标志/参数（形式类似函数传参）/跟表达式（返回）

匿名函数存在的情况：

执行完这行之后，如果没有被赋值给别的变量
其引用计数为0，就会被内存垃圾回收机制清空

from functoolimport reduce

• sorted 倒序并且生成新列表/sort是仅仅倒序
• map 映射
• reduce 合成累加
• filter 过滤

内置函数

build_in function

• all 所有为真，返回真
• any 一个为真，返回真
• chr 数字转换成ascii码
• ord 相反
• complex 复数/.imag/.real
• dir 查看对象可使用的方法
• divmod 查看商和余数
• enumerate 得到一个迭代器
• pow 取模运算
• zip 将两个可迭代元素结合，返回元组结果
• round 四舍五入，为0.5结尾时返回与其最接近的偶数

函数式编程

递归

age(5) = age(4)+2    #n = 5 age(n) = age(n-1)+2
age(4) = age(3)+2    #n = 4 age(n) = age(n-1)+2
age(3) = age(2)+2    #n = 3 age(n) = age(n-1)+2
age(2) = age(1)+2    #n = 2 age(n) = age(n-1)+2
age(1) = 10        #n = 1 age(n) = 10

递归的表示：

def age(n):
    if n ==1:
        return 10
    else:
        return age(n) = age(n-1)+2

栈(stack)：吃了吐

sys.setrecursionlimit()设置栈深度
sys.getrecursionlimit()查看栈深度

特点：

• 进入一层栈就需要保存一次结果，所以深度在物理条件上有限制
• 但在python的理论层面可以很大
• 效率不高，递归的层次过多会导致栈溢出

必须要有一个明确的结束条件
递归每进入下一层，问题的规模就减少一点

应用场景：
递归使用在“不知道问题需要循环多少次”
理论上，递归能做的事循环都能完成

有序列表date = [….]
二分法查找：

date = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]

def two_find(num,list):
    print(list)
    # 首先需要判断传入list的长度，因为当list长度为3的时候
    # 二分以后的list长度会变成1，从而直接进入else进行判断
    # 这时候的list[0]不一定是想要取得值
    if len(list)>1:
        n = len(list) // 2
        if num>list[n]:
            list = list[n:]
            two_find(num,list)
        elif num<list[n]:
            list = list[:n]
            two_find(num,list)
        elif num == list[n]:
            print(‘find‘)
    else:
        if list[0]==num:
            print(‘y‘)
        else:
            print(‘n‘)

two_find(17,date)

遍历的方法寻找数字，对内存占用较大，不推荐

def search(n):
    if date[n-1]==19:
        print(‘True‘)
    else:
        return search(n+1)

函数式编程

1. 不修改外部传参的状态
2. 函数式编程会很精简，可读性不强

面向对象的程序设计

类：

1. 实例化
2. 引用名字（类名.变量名，类名.函数名）

实例：

引用名字（实例名.类变量，实例名.绑定方法，实例.实力自己的变量名）

类中的变量，可以进行增删改查

方法中的变量，也是可以增删改查

OOP

class Student:
    country = ‘china‘
    def __init__(self,ID,NAME,SEX,PROVINCE):
        self.id = ID
        self.name = NAME
        self.sex = SEX
        self.province = PROVINCE
    def search_score(self):
        print(‘tell score‘)
    def study(self):
        print(‘study‘)

s1 = Student(‘9527‘,‘scott‘,‘male‘,‘zhejiang‘)

Student.__init__(s1,‘9527‘,‘scott‘,‘mail‘,‘zhejiang‘)


s1.search_score()

在python3中，所有类都是新式类
class A:pass
在python2中，新式类：

class B(object):pass
class C(B):pass
print(B.__bases__)
print(C.__bases__)

继承自object的都是新式类

类的用法：
实例化

s1 = Student(‘9527‘,‘scott‘,‘male‘,‘zhejiang‘)

Student.__init__(s1,‘9527‘,‘scott‘,‘mail‘,‘zhejiang‘)

属性引用：特征（变量）和技能（函数、绑定方法）

print(s1.name)

print(s1.study())

类的命名空间：

Student.x = 1
print(Student.x)
x = 10000
print(Student.x)

类的增删改查
删：del Student.x

• 对象也称为实例
• 对象的属性：对象本身只有特征（变量）
• 对象的用法：属性引用

类的名称空间/对象的名称空间

查看类的名称空间
print(Student.dict)
查看对象的名称空间
print(s1.dict)
print(s1.id)

比较对象s1的方法，和类当中的方法的id号可以发现
这两个东西，并不是同一个。
print(s1.study,id(s1.study))
print(Student.study,id(Student.study))

绑定方法的核心在于“绑定”，为已绑定一个确定的对象