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

Posted 简明现代魔法

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了11.高阶函数(匿名/*递归/函数式)对象编程基础相关的知识,希望对你有一定的参考价值。

高阶函数

匿名函数

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))

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

以上是关于11.高阶函数(匿名/*递归/函数式)对象编程基础的主要内容,如果未能解决你的问题,请参考以下文章

Scala基础高阶函数隐式转换AKKA编程

python--函数式编程 (高阶函数(map , reduce ,filter,sorted),匿名函数(lambda))

Python 函数式编程: 匿名函数高阶函数装饰器

Scala基础:作为值的函数及匿名函数柯里化闭包及控制抽象

python基础之推导式及匿名函数和高阶函数

13.函数式编程:匿名函数高阶函数装饰器