一、递归调用
递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用；递归调用分为递归和回溯两个阶段
#示例： #场景:已知A的工资比B的工资多200;B的工资比C的工资多200;C的工资比D的工资多200；D的工资比E的工资多200；E的工资为8000；求A的工资 def salary(n): if n==1: return 8000 else: return salary(n-1)+200 salary_A=salary(5) print(salary_A)
#注意事项：
python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化； 但是python又没有尾递归，且对递归层级做了限制
#总结递归的使用：
1. 必须有一个明确的结束条件 2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少 3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
#修改递归的最大深度
import sys sys.getrecursionlimit() sys.setrecursionlimit(2000) n=1 def test(): global n print(n) n+=1 test() test() #虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归
二、二分法
#场景： #要求查看某一列表中是否有有某个值，该列表中数值由小到大的顺序排列（即实现类似与in的功能） num_list=[1,2,3,10,30,45,66,80,200,300,500,770] def get_num(num,num_list): mid=len(num_list)//2 if num_list: if num_list[mid] > num: num_list=num_list[:mid] elif num_list[mid] < num: num_list=num_list[mid+1:] else: print('find it') return get_num(num,num_list) else: print('not find') return get_num(210,num_list)
三、匿名函数
没有名字的函数；只能使用一次
lambda x,y,z:x+y+z #作用同下列有名函数： def func(x,y,z): return x+y+z
#有名函数与匿名函数的对比
有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能 匿名函数：一次性使用，随时随时定义 应用：max，min，sorted,map,reduce,filter
#员工工资信息如下列字典，求最大工资# ，最小工资，和排序 salaries={ 'egon':3000, 'alex':100000000, 'wupeiqi':10000, 'yuanhao':2000 } # 用匿名函数 print(max(salaries,key=lambda k:salaries[k])) print(min(salaries,key=lambda k:salaries[k])) print(sorted(salaries,key=lambda k:salaries[k])) # 用zip拉链 salaries_and_name=zip(salaries.values(),salaries.keys())#迭代器，只能访问一次 print(max(salaries_and_name)) salaries_and_name=zip(salaries.values(),salaries.keys()) print(min(salaries_and_name)) salaries_and_name=zip(salaries.values(),salaries.keys()) print(sorted(salaries_and_name))
四、内置函数
#优先掌握 #max、#min、#sorted--->示例参见上文匿名函数中的应用示例内容 #map #map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。 #例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] ;如果希望把list的每个元素都作平方，就可以用map()函数;map返回的是一个生成器，可以用list转为列表 num_list=[i for i in range(1,10)] new=map(lambda i:i*i,num_list) print(list(new),type(new)) # reduce # reduce()函数也是Python内置的一个高阶函数。 # reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数， # reduce()对list的每个元素反复调用函数f，并返回最终结果值。 # 例如，编写一个f函数，接收x和y，返回x和y的和： # 求和，依次相加如[0,1,2,3,4,5,6,7,8,9] # 0+1=1 # 1+2=3 # 3+3=6 # 6+4=10 # ...... from _functools import reduce num_list=[i for i in range(1,10)] num=reduce(lambda x,y:x+y,num_list) num2=reduce(lambda x,y:x+y,num_list,100)#第三个参数作为计算的初始值 print(num,num2) # filter #filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list， # 这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素， # 返回由符合条件元素组成的新list。 #要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数： num_list=[1,4,6,7,9,12,17] new=filter(lambda i:i%2,num_list) print(list(new),type(new)) # sum print(sum([i for i in range(1,11)])) # bool print(bool([]),bool(''),bool(None),bool(0)) # chr #将ascii码转换为对应的字符 print(chr(65)) #ord #将字符转为对应的ascii码 print(ord('A')) # divmod #取商和余数 print(divmod(7,2)) # enumerate #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列， # 同时列出数据和数据下标，一般用在 for 循环当中。 seasons = ['Spring', 'Summer', 'Fall', 'Winter'] print(list(enumerate(seasons)),type(enumerate(seasons))) print(list(enumerate(seasons,start=2)))#start指定起始以序号值 # id #内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置， #但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，最精准的还是以内存地址为准。 #is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型 # input # print #isinstance #判断对象类型，返回bool值 l=[1,2,'q'] print(isinstance(l,list)) # iter #将迭代器转换为生成器 l=[1,2,3] new_l=iter(l) print(next(new_l)) print(next(new_l)) # len # open # pow print(pow(10,2,3)) #10**2%3 # type # zip #使用zip()函数来可以把列表合并，并创建一个元组对的列表。 l1=[1,2,3,4] l2=['q','a'] new=zip(l1,l2) print(list(new),type(new))
五、模块与包
5.1模块
5.1.1模块的定义
一个模块就是一个包含了python定义和声明的文件（文件名就是模块名字加上.py的后缀），模块可以被导入使用。
import加载的模块分为四个通用类别：
1 使用python编写的.py文件
2 已被编译为共享库或DLL的C或C++扩展
3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
4 使用C编写并链接到python解释器的内置模块
5.1.2模块的使用
#模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第 #一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同 #一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块 #名加载到内存了，后续的import语句仅是对已经加载大内存中的模块对象增加了一次引用， #不会重新执行模块内的语句），如下 #test.py import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的*代码也都被执行了,只不过没有显示效果. import spam import spam import spam ''' 执行结果： from the spam.py ''' #ps：我们可以从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。 #首次import时做了三件事 #1.为源文件(spam模块)创建新的名称空间，在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。 #2.在新创建的命名空间中执行模块中包含的代码，见初始导入import spam 提示:导入模块时到底执行了什么？ In fact function definitions are also ‘statements’ that are ‘executed’; the execution of a module-level function definition enters the function name in the module’s global symbol table. 事实上函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放 入模块全局名称空间表，用globals()可以查看 #3.创建名字spam来引用该命名空间 这个名字和变量名没什么区别，都是‘第一类的’，且使用spam.名字的方式 可以访问spam.py文件中定义的名字，spam.名字与test.py中的名字来自 两个完全不同的地方。 #每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当 #做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局 #变量会在被导入时，与使用者的全局变量冲突 #4、为模块名起别名 #为已经导入的模块起别名的方式对编写可扩展的代码很有用 import spam as sm print(sm.money) #5、在一行导入多个模块 import sys,os,re #6、from...import 与import的对比 #唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：spam. #6from...import...的方式有好处也有坏处 好处：使用起来方便了 坏处：容易与当前执行文件中的名字冲突 #也支持as from spam import read1 as read #也支持导入多行 from spam import (read1, read2, money) #from...import * #from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置 #大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。 #可以使用__all__来控制*（用来发布新版本），在spam.py中新增一行 __all__=['money','read1'] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字
5.1.3 模块重载
python 重载模块必须重启程序，python不支持重新加载或卸载之前导入的模块；如果只是你想交互测试的一个模块，使用 importlib.reload(), e.g. import importlib; importlib.reload(modulename)，这只能用于测试环境。
5.1.4 模块的搜索路径
1）查看内存中是否已经加载相应模块，
2）1中没有则，查找同名的内建模块，
3）2中没有则在sys.path给出的目录列表中依次寻找相应文件
ps:#在初始化后，python程序可以修改sys.path,路径放到前面的优先于标准库被加载。
>>> import sys 2
>>> sys.path.append('/a/b/c/d')
>>> sys.path.insert(0,'/x/y/z')
注意：搜索时按照sys.path中从左到右的顺序查找，位于前的优先被查找，sys.path中还可能包含.zip归档文件和.egg文件，python会把.zip归档文件当成一个目录去处理，
#首先制作归档文件：zip module.zip foo.py bar.py
import sys sys.path.append('module.zip') import foo,bar #也可以使用zip中目录结构的具体位置
sys.path.append('module.zip/lib/python') #windows下的路径不加r开头，会语法错误
sys.path.insert(0,r'C:\Users\Administrator\PycharmProjects\a') #至于.egg文件是由setuptools创建的包，这是按照第三方python库和扩展时使用的一种常见格式，.egg文件实际上只是添 加了额外元数据(如版本号，依赖项等)的.zip文件。
#需要强调的一点是：只能从.zip文件中导入.py，.pyc等文件。使用C编写的共享库和扩展块无法直接从.zip文件中加载（此时setuptools等打包系统有时能提供一种规避方法），且从.zip中加载文件不会创建.pyc或者.pyo文件，因此一定要事先创建他们，来避免加载模块是性能下降。
ps:python中.py文件的两种应用
#编写好的一个python文件可以有两种用途： 一：脚本，一个文件就是整个程序，用来被执行 二：模块，文件中存放着一堆功能，用来被导入使用 #python为我们内置了全局变量__name__， 当文件被当做脚本执行时：__name__ 等于'__main__' 当文件被当做模块导入时：__name__等于模块名 #作用：用来控制.py文件在不同的应用场景下执行不同的逻辑 if __name__ == '__main__': #fib.py def fib(n): # write Fibonacci series up to n a, b = 0, 1 while b < n: print(b, end=' ') a, b = b, a+b print() def fib2(n): # return Fibonacci series up to n result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, a+b return result if __name__ == "__main__": import sys fib(int(sys.argv[1])) #执行：python fib.py <arguments> python fib.py 50 #在命令行
5.2 包
5.2.1包的定义
包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来
5.2.2包的使用
1) 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
2) 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块\
3)关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
4)import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件
5)包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间
#文件内容 #policy.py def get(): print('from policy.py') #versions.py def create_resource(conf): print('from version.py: ',conf) #manage.py def main(): print('from manage.py') #models.py def register_models(engine): print('from models.py: ',engine)
#import import glance.db.models glance.db.models.register_models('mysql') #单独导入包名称时不会导入包中所有包含的所有子模块，如 #在与glance同级的test.py中 import glance glance.cmd.manage.main() ''' 执行结果： AttributeError: module 'glance' has no attribute 'cmd' ''' #解决方法： #glance/__init__.py#在此文件中写入如下内容 from . import cmd #glance/cmd/__init__.py from . import manage ##from ... import ... #需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法 from glance.db import models models.register_models('mysql') from glance.db.models import register_models register_models('mysql') ##from glance.api import * 在讲模块时，我们已经讨论过了从一个模块内导入所有*，此处我们研究从一个包导入所有*。 此处是想从包api中导入所有，实际上该语句只会导入包api下__init__.py文件中定义的名字，我们可以在这个文件中定义__all___: #在__init__.py中定义 x=10 def func(): print('from api.__init.py') __all__=['x','func','policy'] 此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容（versions仍然不能导入）。 ##绝对导入和相对导入 我们的最*包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式： 绝对导入：以glance作为起始 相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内） 例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py 在glance/api/version.py #绝对导入 from glance.cmd import manage manage.main() #相对导入 from ..cmd import manage manage.main() ###注意### 包以及包所包含的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的 比如我们想在glance/api/versions.py中导入glance/api/policy.py，有的同学一抽这俩模块是在同一个目录下，十分开心的就去做了，它直接这么做 #在version.py中 import policy policy.get() 没错，我们单独运行version.py是一点问题没有的，运行version.py的路径搜索就是从当前路径开始的，于是在导入policy时能在当前目录下找到 但是你想啊，你子包中的模块version.py极有可能是被一个glance包同一级别的其他文件导入，比如我们在于glance同级下的一个test.py文件中导入version.py，如下 from glance.api import versions ''' 执行结果: ImportError: No module named 'policy' ''' ''' #分析: 此时我们导入versions在versions.py中执行 import policy需要找从sys.path也就是从当前目录找policy.py, 这必然是找不到的 '''