在函数内部，可以调用其他函数，如果一个函数在内部调用自身本身，这个函数就是递归函数。
递归效率低，需要在进入下一次递归时保留当前的状态，解决方法是尾递归，即在函数的最后一步(而非最后一行)调用自己，但是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) 总结：
类：一：实例化，二：引用名字（类名.变量名，类名.函数名）
实例：引用名字（实例名.类的变量，实例名.绑定方法，实例名.实例自己的变量名）