递归函数及常用的内置方法

 

一、递归函数的定义： 在函数体内再调用函数本身（简单的说就是多次甚至无限的循环）　　　

# 简单的递归
 def func(index)
        print('form index')
        return login()
def func(login)
        print(''form login')
        return index()
login()

##嵌套调用，进入多次循环，直到递归深度上限

 

                                      提示超过了内置的递归深度

 

1：递归的最大深度——997

　　　　如果在函数体内使用递归函数那么程序就不停的运行着，这会导致数据的存储量过大，内存会溢出，Python为了杜绝这类现象的发生，定义了一个强制的将递归层数控制在了997。

      查看函数最大递归深度：

import sys
  print(sys.getrecursionlimit())
               # 查看最大的递归深度范围
 print(sys.setrecursionlimit(2000))
               # 修改递归深度的范围值
              

2：递归函数的实现过程：

　　　　　1:回溯：就是一次次重复的过程，重复的过程必须在逐渐的降低问题的复查程度，直到找到一个最终的结束条件

　　　　　2：递归：就是拿到条件后 ，一次次往回推导的过程

def age(n):
    if n==1: # 第一个开始回溯的人
        return 18 # 结束的条件
    else:
        return age(n-1)+2 #递推的规律
res=age(10)
print(res)

二、算法之二分法：所谓的算法就是提高效率的方法，    二分法：就是容器内必须有一定的大小顺序，以中间数为基准寻找规律，分段比较左右对比

　　

l=[1,4,8,9,14,25,48,58,124,236,485,489,520,1234,4526,7852]
def func(l,aim):
    mid=(len(1)-1)//2 # 先取列表的中间值
    if l:
        if aim>l[mid]:
            func(1[mid+1:],aim) # 按索引的方式取值
        elif aim<l[mid]:
            func(1[:mid],aim)
        elif aim==l[mid]:
            print('bingo',mid)
        else:
            print('找不到')
    func(1,124)   # 124是要找的数
    func(1,8)    #  8是分段寻找 前后取出在对比

三、三元表达式：

　　　　三元表达式固定表达式
   　　　　　　　　 值1 if 条件 else 值2
        　　　　　　　　条件成立 值1
        　　　　　　　　条件不成立 值2

当表达式例有一个条件使得结果不执行这个，就执行另一个时，常采用三元表达式更简单

 

def my_max(x,y):
    if x>y:
        return x
    else:
        return y
res=my_max(1,9)
print(res)

    上述表达式等价于   res = x if x > y else y   如果if后面的条件成立返回if前面的值，否则返回else后面的值

=555
y=3313
res=x if x>y else y
print(res)

>>3313

 

四、列表的生成式：往列表里添加或修改内容

l=['tank','nick','oscar','topa','kevin','jamse']
k=[]
for name in l:
    k .append('%s_boy'%name) # k.append（name+'boy'）但不推荐使用，pycharm里效率极低
print(k)
   

运行的结果

>>['tank_boy', 'nick_boy', 'oscar_boy', 'topa_boy', 'kevin_boy', 'jamse_boy']

 

等价于： 

res = [ '%s_boy' %name  for  name  in l ]         

print(res)

res = [name for name in l if name.endswith('_sb')   #  关键字.endswith

l=['tank','nick','oscar','topa','kevin','jamse']

res=['%s_boy'%name for name in l]
print(res)

结果：
>>
>>['tank_boy', 'nick_boy', 'oscar_boy', 'topa_boy', 'kevin_boy', 'jamse_boy']

　　先 for 循环依次取出列表里面的每一个元素，然后先交给 if 判断   条件成立才会交给  for前面的代码

 

五、字典生成式：内部都是基于 for  循环   以 key:vlaue 键值对的形式生成列表 list，关键字 enumerate

ser=['kevin', '1213',read]
d={i=j for i ,j in enumerate(l1)} if j！=‘123’
print（d）

 

六、匿名函数：

　　　　 定义的规范： 函数名 = lambda 参数 ：返回值

就是没有函数的名字，在调用阶段只是暂时的命名，用完就不起作用了

　　　

 

   一般不会单独使用，常与内置函数搭配使用

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

 

七、常用的内置函数;

 　　　　　　map（映射） zip（拉链） filter（过滤） sorted（排序） reduce（减少） 大部分都是基于for循环

map：

l=[1,12,45,54,65,78]
print(list(map(lambda x:x+5,l))) # 映射相当于for循环 对列表里赋值

>>>[6, 17, 50, 59, 70, 83]  对应的都+5

zip:

l1 = [1,2,3,4,5]
l2 = ['jason','egon','tank'] # 按位置对称以元祖的形式返回，多的没有对应的就不返回：
print(list(zip(l1,l2)))


>>>>[(1, 'jason'), (2, 'egon'), (3, 'tank')]

 filter：执行的条件是：当返回的值为True时才执行，为Flase 直接过滤掉（ x:x != 3）

l = [1,2,3,4,5,6]
print(list(filter(lambda x:x != 3,l))) # 过滤掉不等于3的数 返回


>>>[1, 2, 4, 5, 6]

 

 

文件操作相关：

open()  打开一个文件，返回一个文件操作符(文件句柄)

操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)

可以用encoding指定编码.

 

 

数字——数据类型相关：bool，int，float，complex

数字——进制转换相关：bin，oct，hex

数字——数学运算：abs，divmod，min，max，sum，round，pow

 

作用域相关的：

基于字典的形式获取局部变量和全局变量

globals()——获取全局变量的字典

locals()——获取执行本方法所在命名空间内的局部变量的字典

 

 d = {
#     'egon':30000,
#     'jason':88888888888,
#     'nick':3000,
#     'tank':1000
# }
# def index(name):
#     return d[name]

# print(max(d,key=lambda name:d[name]))  #
# 比较薪资 返回人名
# print(min(d,key=lambda name:d[name])) #  通过key取值调用数字给d,然后在做比较

 

 

 

 

 

　　　　　　

 

 

  

 

 

 

　

转载于:https://www.cnblogs.com/Gaimo/p/11176371.html