函数递归调用、模块、三元表达式、匿名函数、

一、函数递归调用

函数的递归调用：就是在调用一个函数的过程中又直接或间接地调用自己

# 示例一：直接调用
# def foo():
#     print('hello')
#     foo()
#
# foo()

# 示例二：间接调用自己
# def bar():
#     print('from bar')
#     foo()
#
# def foo():
#     print('hello')
#     bar()
#
# foo()
# 异常：maximum recursion depth exceeded while calling a Python object

为何死递归会抛出异常???
因为无限的递归会导致内存溢出，所以python设定了最大的递归层数

import sys
print(sys.getrecursionlimit())  #  最大递归层数1000

解决的方式是手工设置递归调用深度，方式为：

# import sys
# print(sys.setrecursionlimit(2000) )

所以：不应该无限递归调用下去，应该在满足某种条件下结束递归调用，然后返回

递归调用应该分为两个阶段

1、回溯（挖井） ：一层一层地递归调用下去
2、递推（从井里往外跳）：在满足某一条件的情况下结束回溯，然后开始向上一层层返回

# salary(5) = salary(4) + 10
# salary(4) = salary(3) + 10
# salary(3) = salary(2) + 10
# salary(2) = salary(1) + 10
# salary(1) = 18


# n=1   salary(n) = 18
# n!=1  salary(n) = salary(n-1) + 10

# def salary(n):
#     if n == 1:
#         return 18
#     return salary(n-1) + 10
#
# res=salary(5)
# print(res)

# nums=[111,[222,[333,[444,[5555,[6666,[777,[888,[9999]]]]]]]]]
# def func(l):
#     for x in l:
#         if type(x) is list:
#             # 把自身的代码重新再调用一次
#             func(x)
#         else:
#             print(x)
# func(nums)

从小到大排列的一个数字列表

# nums = [11, 13, 32, 47, 53, 73, 84, 91]
#
# find_num = 54
# def binary_search(l,finde_num):
#     print(l)
#     mid_index = len(l) // 2
#     if find_num  > l[mid_index]:
#         right_l = l[mid_index+1:]
#         binary_search(right_l,find_num)
#     elif find_num < l[mid_index]:
#         left_l = l[:mid_index]
#         binary_search((left_l,find_num))
#     else:
#         print('find it')
#
# binary_search(nums,84)
# 循环报错：maximum recursion depth exceeded while calling a Python object

改法：用到二分法

# nums = [11,13,32,47,53,73,84,91,101,111,222,333,444,5555]
# def binary_search(l,find_num):
#     print(l)
#     if len(l) == 0:
#         print('find_num not exists')
#         return
#     mid_index = len(l) // 2
#     if find_num > l[mid_index]:
#         right_l = l[mid_index +1:]
#         binary_search(right_l,find_num)
#     elif find_num < l[mid_index]:
#         left_l = l[:mid_index]
#         binary_search(left_l,find_num)
#     else:
#         print('find it')
#
# binary_search(nums,85)

# 结果
#[11, 13, 32, 47, 53, 73, 84, 91, 101, 111, 222, 333, 444, 5555]
# [11, 13, 32, 47, 53, 73, 84]
# [53, 73, 84]
# [84]
# []
# find_num not exists

# nums = [11,13,32,47,53,73,84,91,101,111,222,333,444,5555]
# def binary_search(l,find_num):
#     print(l)
#     if len(l) == 0:
#         print('find_num not exists')
#         return
#     mid_index = len(l) // 2
#     if find_num > l[mid_index]:
#         right_l = l[mid_index +1:]
#         binary_search(right_l,find_num)
#     elif find_num < l[mid_index]:
#         left_l = l[:mid_index]
#         binary_search(left_l,find_num)
#     else:
#         print('find it')
# binary_search(nums,53)

# 结果
# [11, 13, 32, 47, 53, 73, 84, 91, 101, 111, 222, 333, 444, 5555]
# [11, 13, 32, 47, 53, 73, 84]
# [53, 73, 84]
# [53]
# find it

二、三元表达式

三元表达式:表达式1 if 条件 else 表达式2

# def max2(x,y):
#     if x >y:
#         return x
#     else:
#         return y
#
# 三元式：
# x = 111
# y =222
# res = x if x > y else y
# print(res)
#

# name = input('your name:').strip()
# res = 'leon' if name == 'yoyo' else 'love'
# print(res)

三、匿名函数

匿名函数即没有名字的函数

# res = (lambda x, y:x+y)(1,2)
# print(res)

# f = lambda x, y :x+y
# print(f)
# f(1,2)
# 结果：
# <function <lambda> at 0x10459a1f0>

特点：没有名字意味着只能用一次，用完之后就是垃圾，所以匿名函数只用于临时使用一次的场景

# salaries = {
#     'egon':4.4,
#     'lqz':3.3,
#     'yj':2.2
# }
# def func(k):
#     return salaries[k]

# 求最大值，返回的是key（egon）
# print(max(salaries, key = lambda k :salaries[k])) 
 
# 求最小值，返回的是key（yj）
# print(min(salaries,key = lambda k:salaries[k])) 
   
# 从小到大的顺排列['yj', 'lqz', 'egon']
# print(sorted(salaries,key=lambda k:salaries[k]))  

# 从大到小的顺序排列 ['egon', 'lqz', 'yj']
# print(sorted(salaries,key=lambda k:salaries[k],reverse=True))  

四、模块

1、什么是模块
模块就是一个功能的集合体，不是用来直接运行，而是用来被导入使用的

模块分为三大来源：
1、内置的模块
2、第三方模块
3、自定义的模块



模块分为四种类别：
1、一个py文件就是一个模块
2、一个文件夹也是一个模块===》包
3、已被编译为共享库或DLL的C或C++扩展
4、使用C编写并链接到python解释器的内置模块

2、为何要用模块
使用别人的模块：
1、拿来主义，提升开发效率
自定义模块：
1、别人的功能不够用了，需要自己去编写
2、解决代码冗余

3、如何用模块
一个要被导入的文件模块

# spam.py
print('from the spam.py')

money = 1000


def read1():
    print('spam模块：', money)


def read2():
    print('spam模块')
    read1()


def change():
    global money
    money = 0

文件名是spam.py，模块名则是spam

首次导入模块发生的事情
1、触发被导入的模块运行，产生一个模块的名称空间，把模块中的名字都丢进去
2、会在当前执行文件中得到一个名字spam，该名字是指像被导入模块的名称空间的

# import day16.spam
# # x = 111
# money = 2000
# print(money) #当前模块值，不会改变
# print(day16.spam.money)
#
# day16.spam.read1()
# def read1():
#     print('模块.py'---read1)
#
# day16.spam.read2()
# def read2():
#     print('模块.py---read2')
#
# day16.spam.change()
# print(day16.spam.money)

之后的导入，名字spam直接引用首次导入产生的名称空间，不会再执行模块内的代码了

# import spam
# import spam
# import spam

一行导入多个模块

# import day16.spam,m1,m2,m3

为导入的模块起别名

# import day16.spamasdfasfsadfadfasfd as sm
# sm.xxx
# 示例：
# # mysql.py
# def sqlparse():
#     print('from mysql sqlparse')

# #oracle.py
# def sqlparse():
#     print('from mysql sqlparse')
# 
# # tset.py
# db_type = input('>>>:')
# if db_type == 'mysql':
#     import mysql as db
# elif db_type == 'oracle':
#     import oracle as db
# db.salparse()

from导入

# from spam import money,read1,read2   
#money=spam.money,read1=spam.read1,read2=spam.read2

#    money=模块spam中的money对应值的内存地址
#    read1=模块spam中的read1对应值的内存地址
#    read2=模块spam中的read2对应值的内存地址

# from spam import money,read1,read2
# from spam import money,read1,read2
# from spam import money,read1,read2
# from spam import money,read1,read2

# print(money)
# print(read1)
# print(read2)


# money=111  #当前文件下的值会覆盖导入模块的值
# print(money)

# money=2000 #当前文件下的值会覆盖导入模块的值
# read1()

# def read1():
#     print('run.py read1')
# read2()

# 一行导入多个名字
# from spam import money,read1

# 为导入的模块起别名
# from spam import money as m
#
# print(m)

# from spam import *
from spam import *    # *访问spam所有模块名
# print(money)
# print(read1)
# print(read2)
print(change)

用*时需要注意
导入模块不对外访问的参数可以用–all–来对**进行限制