python递归 及 面向对象初识及编程思想

Posted 2020-10-09

一、递归

1、定义：

　　在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

　　（1）递归就是在过程或函数里调用自身；
　　（2）在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

1 def age(n):
2     if n ==1:   #条件判定
3         return 10  #返回一个结果
4     else:
5         return age(n-1)+2  #重复调用函数本身，系统会将运算的结果存放到栈，然后再依次的进行取值调用。
6 print(age(5))   #打印结果

　执行结果：18

2、优缺点：　　

　　递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

　　递归的缺点：递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。

def func():
    print("*******")
    func()
func()

#执行结果
 [Previous line repeated 993 more times]
*******
  File "F:/py_fullstack_s4/day26/递归.py", line 8, in func
*******
    print("*******")
*******
RecursionError: maximum recursion depth exceeded while calling a Python object

3、递归编程的注意点：

　　1. 必须有一个明确的结束条件。

　　2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少。

　　3.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）。

4、此处引出一个新的知识点：二分法

　　二分法，是一种快速查找的方法，时间复杂度低，逻辑简单易懂，总的来说就是不断的除以2除以2...

　　他主要应用于有序序列中，原理是每次查找都将原序列折半，逐渐缩小查找范围的一种算法。应用于递归，循环之中，直到找到结果。

#运用 递归 和 二分法 的运算方式，查找列表中的某个值
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
num = int(input("please input your want to find number:"))
def search(num,data):
    if len(data) > 1:      #排除列表分割，仅剩一个元素的情况
         #二分法#
        a = int(len(data)//2)   #将计算列表的长度，除以2  取整数
        mid_value = data[a]     #取当前中间的值
        if num > mid_value:     #要找的值 大于 中间的值
            data = data[a:]     #将原列表从中间值往后，取出来，构建一个新列表
            search(num,data)    #递归判断
        elif num < mid_value:   #要找的值 小于 中间的值
            data = data[:a]     #将原列表开始到中间值，取出来，构建一个新列表
            search(num,data)    #递归判断
        else:                   #正好是这个值
            print("find it!!",num)
            return          #打印
    else:                         #判断列表分割，仅剩一个元素的情况
        if data[0] == num:
            print(‘find it!! %s‘%data[0])
        else:                     #列表中没有这个值
            print(‘not this num %s‘%num)

search(num,data)

#执行结果：
please input your want to find number:18
find it!! 18

二、函数式编程介绍

1、用def模仿数学中函数的方式，传一个值，就得一个结果。不会修改外部的状态。
2、代码非常的精简，直接导致可读性非常差。

三、面向对象的程序设计

1、前提铺垫：

　　python中一切皆为对象，python 3统一了类与类型的概念，类型即是类。例如：int，str，list，等等……

　　编程语言中，是先有了类，然后再产生一个个对象。而现实生活中正好相反。

　　明确一点：面向对象编程是一种编程方式，此编程方式的功能需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含创建多个函数，函数里实现自定义的功能

　　对象则是根据模板创建的实例，通过实例(对象)可以执行类中定义的函数

2、语法：

　　1）创建类：class是关键字，表示类 class *** #创建类
　　2）创建对象：类名称后加括号 将结果赋给一个变量 即可 x = ***() #创建对象

 

 1 class hello:  #任意定义一个类
 2     camp = ‘hello world‘
 3     def f(self):
 4         print("f")
 5 h = hello() # 类实例化
 6 print(h) #打印
 7 
 8 #执行结果：
 9 
10 <__main__.hello object at 0x00000000026C9630>

3、类与对象

1）什么是对象：
　　以游戏举例：英雄联盟，每个玩家选一个英雄，每个英雄都有自己的特征和和技能，特征即数据属性，技能即方法属性，特征与技能的结合体就一个对象。

2）什么是类：
　　从一组对象中提取对象共同的 特征，技能，构成一个类。类也是特征与技能的结合体，特征即数据并且是所有对象共享的数据，技能即函数属性并且是所有对象共享的函数属性。　

　　①优点：解决了程序的扩展性，对某个对象进行修改，会立刻反映到整个体系中
　　②缺点：可控性差，无法预测最终的结果。
　　面向对象的程序设计并不是程序全部。对于软件质量来说，面向对象的程序设计只是用来解决扩展性的问题。

def 或是 class 都是在定义一个函数名。class 定义 类 　　 camp 阵营 　　 attack(self) 技能 　　 nickname昵称 　　 init 开始，初始

3）如何使用类：
　一、实例化

　　类的实例化就会产生一个实例（对象）。 可以理解为类加()把虚拟的东西实例化，得到具体存在的值，叫做类的实例化。

class Garen:  #定义一个类
    camp = ‘Demacia‘
def attack(self):
    print(‘attack‘)
g1 = Garen() #类的实例化，产生一个对象，可以调用类内包括的所有特征（共性）。
print(g1)  #打印

#执行结果：
<__main__.Garen object at 0x00000000028C9CC0>

　二、类通过.（点）的方式引用特征（类的变量）和技能（类的函数（类内部还是定义的函数，调用的话还是需要传入参数））

class Garen:
    camp=‘Demacia‘
    def attack(self):
        print(‘attack‘)
print(Garen.camp)  #查看camp
print(Garen.attack)   #打印数据类型
Garen.attack(‘nihao‘) #由于是调用有参函数，需要传值

#执行结果：
Demacia
<function Garen.attack at 0x000000000229C950>
attack

2、对象之间也有不同，及除了同性也有特性。例如昵称！

class Garen:
    camp=‘Demacia‘

    def __init__(self,nickname):
        self.nick=nickname  #给实例自己定义一个别名，由外部传入 #g1.nick = ‘草丛伦‘
    def attack(self,enemy):
        # print(‘---------->‘,self.nick) #g1.nick
        print(‘%s attack %s‘ %(self.nick,enemy))


g1=Garen(‘草丛伦‘) #类实例化，类Garen触发调用_init_ #Garen._init_(self,‘NB‘)
g2=Garen(‘刘下‘)
print(g1.nick)
g1.attack(‘alex‘)

#执行结果：
草丛伦
草丛伦 attack alex

self 指自己。

注意：类的实例化就会自动触发类内_init_函数的执行。

3、怎么调用类的特征与技能

注意：类与对象之间的绑定方法。调用绑定方法，python 会自动传值，会将调用者本身当作参数传给self，第一值。
print(gi.attack) #调用绑定方法，类绑定给g1
print(Garen.attack) #函数

class Garen:
    camp=‘Demacia‘

    def __init__(self,nickname):
        self.nick=nickname  #给实例自己定义一个别名，由外部传入 #g1.nick = ‘草丛伦‘
    def attack(self,enemy):
        # print(‘---------->‘,self.nick) #g1.nick
        print(‘%s attack %s‘ %(self.nick,enemy))


g1=Garen(‘草丛伦‘) #类实例化，类Garen触发调用_init_ #Garen._init_(self,‘NB‘)
g2=Garen(‘刘下‘)

print(g1.nick)  #昵称
print(g1.camp)  #阵营
print(g1.attack)  #打印 查看绑定方法
print(Garen.attack)  # 打印 函数

#执行结果：
草丛伦
Demacia
<bound method Garen.attack of <__main__.Garen object at 0x0000000002299D68>>
<function Garen.attack at 0x000000000229C9D8>

Garen.attack(参数)# 调用的是函数，需要传参
g1.attack(‘alex‘) #self = g1；enemy = ‘alex‘若是函数有多个值，就在赋值的时候，传入其他的参数。

print(g1.nick)

只要是对象触发的，调用的时候就会自动给调用的函数传值，将自身传到第一个参数self。若是函数有多个值，就在赋值的时候，对应的传入其他的参数。

class Garen:
    camp=‘Demacia‘

    def __init__(self,nickname):
        self.nick=nickname  #给实例自己定义一个别名，由外部传入 #g1.nick = ‘草丛伦‘
    def attack(self,enemy):
        # print(‘---------->‘,self.nick) #g1.nick
        print(‘%s attack %s‘ %(self.nick,enemy))


g1=Garen(‘草丛伦‘) #类实例化，类Garen触发调用_init_ #Garen._init_(self,‘NB‘)
g2=Garen(‘刘下‘)
print(g2.nick)
print(g2.camp)

#执行结果：
刘下
Demacia

三、总结：
1、类：一：实例化，二：引用名字（类名.变量名，类名.函数名） 得到一个内存地址，加()就能运行。

2、实例（对象）：引用名字(实例名.类的变量，实例名.绑定方法，实例名.实例自己的变量名)

3、类：
　优点：解决了程序的扩展性，对某个对象进行修改，会立刻反映到整个体系中
　缺点：可控性差，无法预测最终的结果。
　　面向对象的程序设计并不是全部。对于软件质量来说，面向对象的程序设计只是用来解决扩展性的问题。

在python中，用变量表示特征，用函数表示方法，因而类是变量与函数的结合体，对象是变量与方法（指向类的函数）的结合体

4、类属性：特征（变量）和方法（函数）

5、类有两种方法：1.类的实例化；2.属性引用
　　1.实例化：
　　　　类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
　　2.属性引用：
　　　　类名.方法

6、对象也称为实例

　　对象的属性：对象本身就自有特征（变量）

　　对象的只有一种用法：属性引用

7、类的名称空间和对象的名称空间

创建一个类，就会创建一个类的名称空间，存放类中定义的属性：特征（数据）和方法（函数）
创建一个对象，及类的实例化，就会创建一个类的名称空间，存放对象的属性。

注意：对象就是类的实例化，类完成实例化的操作就已经将类的方法绑定到对象上，对象调用方法会现在自己的名称空间去找，找不到会去类的名称空间去找，再找不到会抛异常。它不会去找全局的定义。

查看类的名称空间 类名._dict_
查看对象的名称空间 对象名._dict_

绑定方法的核心在于‘绑定’，唯一绑定到一个确定的对象

可以调用：查
print(Garen.camp) #查

可以更改：改
Garen.camp=‘aaaaaa‘ #改
print(Garen.camp)

可以删除： 删
del Garen.camp #删除
print(Garen.camp)

可以添加： 增
Garen.x=1 #增加特征
print(Garen.x)

关于对象（实例）

可以调用： 查
g1=Garen(‘alex‘)
print(g1.nick) #查

可以更改： 改
g1.nick=‘asb‘ #改
print(g1.nick)

可以删除： 删
del g1.nick
print(g1.nick) #删

可以增加： 增
g1.sex=‘female‘
print(g1.sex) #增加

四、面向对象的软件开发：

分为五部：

1、面向对象分析（object oriented analysis,OOA）：
产品经理调研市场，考察，明确软件的用途和应用场景。
2、面向对象设计（object oriented design,OOD）：
根据需求，对每一部分进行具体的设计，例如：类的设计
3、面向对象编程（object oriented programming,OOP）：
将设计编程成代码
4、面向对象测试（object oriented test,OOT）：
对写好的代码进行测试，发现错误并改正。面向对象的测试是用面向对象的方法进行测试，以类为测试的基本单元。
5、面向对象维护（object oriented soft maintenance,OOSM）：
解决用户使用产品过程中出现的问题，或是增加新的功能。

面向对象编程思想：
1、设计的时候，一定要明确应用场景

2、由对象分析定义类的时候，找不到共同特征和技能不用强求