python基础之递归，声明式编程，面向对象（一）

在函数内部，可以调用其他函数，如果一个函数在内部调用自身本身，这个函数就是递归函数。
递归效率低，需要在进入下一次递归时保留当前的状态，解决方法是尾递归，即在函数的最后一步(而非最后一行)调用自己，但是python又没有尾递归，而且

对递归的层级做了限制
递归特性:
1.必须有一个明确的结束条件
2.每次进入更深一层递归时，问题规模比上次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈(stack)这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每

当函数返回，栈就会减一层帧。由于栈的大小是无限的，所以当递归调用次数过多，会导致栈溢出)

递归函数的应用

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]  #声明一个包含数字的列表
def search(num,data):
    if len(data)>1:
        mid_index=int(len(data)/2)  #中间数字的索引等于data列表的长度除以2
        mid_value=data[mid_index]   #中间数字的值等于列表data[索引]
        if num > mid_value:     #如果输入的数字大于列表中间值
            data=data[mid_index:]   #取列表的后半段，也就是列表切片
            search(num,data)    #调用函数
        elif num < mid_value:   #如果输入的数字大于列表中间值
            data=data[:mid_index]   #取列表的前半段，也就是列表切片
            search(num,data)    #调用函数
        else:
            print('find it')    #猜对了
    else:
        if data[0]==num:        #列表元素变成一个时，正好猜到最后一个值
            print('find it')    #猜对了
        else:
            print('not exists') #要找的数字不存在
search(17,data) #调用函数

声明式编程：

#列表解析
l=[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
#生成器表达式
g=(expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
)

面向过程编程特点:

面向过程的程序设计的核心是过程，过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了程序的复杂度

缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象编程:

总结:
类:一:实例化，二:引用名字(类名.变量名， 类名.函数名)
实例:引用名字(实例名.类的变量，实例名.绑定方法，实例名.实例自己的变量名)
定义类和定义函数相似。
把抽象的或者不存在的东西加一个括号得到一个具体存在的对象，这个过程叫实例化

英雄联盟游戏实例:

实例1：
class Garen:    #一堆对象提取共同的特征产生类，由类产生一个个具体的对象，类是盖伦
    camp='Demacia' #camp（阵营）-->德玛西亚
    def attack(self):
        print('attack')
# 如何使用类
# 一：实例化
x=int(10)
print(x)

obj=Garen() #实例化：Garen加括号，这是一个类执行，由类产生一个具体存在的对象，
print(obj)
#二：引用类的特征（累的变量）和技能（类的函数）
print(Garen.camp)
print(Garen.attack) #调用的就是函数

print(Garen.attack(1037727983))

实例2:
class Garen:    #一堆对象提取共同的特征产生类，由类产生一个个具体的对象，类是盖伦
    camp='Demacia' #camp（阵营）-->德玛西亚
    def attack(self):
        print('attack')
    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))
print(Garen.camp)   #查
Garen.camp='aaaaa'  #改
print(Garen.camp)

del Garen.camp  #删除
print(Garen.camp)

Garen.x=1　　#添加
print(Garen.x)#输出

g1=Garen('alex')　　#添加一个攻击的目标'alex'
print(g1.nick)　　　　#输出'alex'
g1.nick='asb'　　　　#更改nick目标alex为'asb'
print(g1.nick)　　#输出'asb'
del g1.nick

g1.sex='female' #添加性别为女性
print(g1.sex)　　#输出sex

实例3:
class Garen:    #一堆对象提取共同的特征产生类，由类产生一个个具体的对象，类是盖伦
    camp='Demacia' #camp（阵营）-->德玛西亚阵营

    def __init__(self,nickname):    #nickname:别名
        self.nick=nickname  #g1.nick='草丛伦
    def attack(self,enemy):
        print('------------>',self.nick)#self.nick就是找self下有没有类
        print('attack %s' %enemy)
g1=Garen('草丛伦') #草丛伦直接传给nickname，把nickname给self下面的一个名字nick,Garen.__init__(g1,'草丛伦')，本质上就是触发__init__的执行
g2=Garen('猥琐轮')
Garen.attack(10)    #调用的就是函数
print(g1.nick)
g1.attack('alex') #g1的值传给self，也就是self=g1
Garen.attack(g1)    #对象调用自己的绑定方法

print(g1)
print(g1.nick)
print(g1.camp)
print(g1.attack)# <bound method Garen.attack of <__main__.Garen object at 0x00000035A6A6CF60>>绑定方法，绑定给g1
print(Garen.attack) #<function Garen.attack at 0x00000035A6A6E950>就是普通函数

print(g2.nick)
print(g2.camp)
print(g1.attack)

总结：
类：一：实例化，二：引用名字（类名.变量名，类名.函数名）
实例：引用名字（实例名.类的变量，实例名.绑定方法，实例名.实例自己的变量名）