python学习第五天

时间:2022-03-18 06:02:23

  

一、递归调用

  递归调用是函数嵌套调用的一种特殊形式,函数在调用时,直接或间接调用了自身,就是递归调用;递归调用分为递归和回溯两个阶段

#示例:
#场景:已知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,
这必然是找不到的
'''