python glob 多层级 python 层级调用

递归

概念：在函数调用过程中，直接或间接地调用了函数本身，这就是函数的递归调用

例子：

#直接调用函数本身
def f1():
    print('from f1')
    f1()

f1()
#间接调用函数本身
def f1():
    print('f1')
    f2()

def f2():
    f1()

f1()

python默认会限制递归调用的层数，可以修改，但是没什么实际用处：

import sys
print(sys.getrecursionlimit())
sys.setrecursionlimit(1000000)
print(sys.getrecursionlimit())

res：

1000
1000000

递归实例（询问年龄）:

def age(n):
    if n == 1:
        return 18
    return age(n-1)+2

print(age(5))

过程剖析：

age(5)=age(4)+2
age(4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)=18

age(n)=age(n-1)+2 n>1
age(n)=18 n=1

如图：

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

堆栈扫盲 

尾递归优化：http://egon09.blog.51cto.com/9161406/1842475

实际例子（利用递归实现二分查找）：

l = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]

def search(find_num,seq):
    if len(seq) == 0:
        print('not exists')
        return
    mid_index=len(seq)//2
    mid_num=seq[mid_index]
    print(seq,mid_num)
    if find_num > mid_num:
        #in the right
        seq=seq[mid_index+1:]
        search(find_num,seq)
    elif find_num < mid_num:
        #in the left
        seq=seq[:mid_index]
        search(find_num,seq)
    else:
        print('find it')

search(77,l)

res：

[1, 2, 10, 33, 53, 71, 73, 75, 77, 85, 101, 201, 202, 999, 11111] 75
[77, 85, 101, 201, 202, 999, 11111] 201
[77, 85, 101] 85
[77] 77
find it

import模块

一、import

import导入模块干的事

1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.拿到一个模块名spam，指向spam.py产生的名称空间

 spam.py内容如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#spam.py
print('from the spam.py')

money=1000

def read1():
print('spam->read1->money',money)

def read2():
print('spam->read2 calling read')
read1()

def change():
global money
money=0

eg1：

import spam
money=1000000000000000000000000000000000000000000
print(spam.money)
print(spam.read1) #打印read1的内存地址
spam.read1() #可以打印地址就可以调用
def read1():
    print('from test.py')
spam.read2() #调用read2，内部还调用的是spam的read1，因为这句是以新建的名称空间为全局名称空间，执行文件的代码

res：

from the spam.py
1000
<function read1 at 0x0000000000B5F378>
spam->read1->money 1000
spam->read2 calling read
spam->read1->money 1000

eg2：

import spam
money=10
spam.change() #修改的是模块新建的名称空间，所以不影响文件级别的变量money
print(money) #打印的是文件级别的money

res：

from the spam.py
10

import模块名的时候可以设置别名，如下：

import spam as x
print(x.money)

res：

from the spam.py
1000

二、from ... import ...

from ... import 导入的是名字即可，函数名、变量名、类名

1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.直接拿到就是spam.py产生的名称空间中的名字

示例：

from spam import money,read1,read2,change

from ... import ...
优点:方便，不用加前缀
缺点：容易跟当前文件的名称空间冲突

示例：

from spam import money,read1,read2,change
print(money)
read1()

money=10 #被当前名称空间中的money覆盖，所以结果为10，函数名、变量名、模块名都是绑定关系，可以重新绑定

# del money  ##NameError: name 'money' is not defined
print(money)

res：

10

示例：

from spam import money,read1,read2,change
def read1():
    print('=========from test.py read1')
read2() #容易和上个例子混淆，跟导入方式无关，函数执行的时候还是以原命名空间为准（函数来自于那个文件，执行的时候就是哪个文件的环境变量）！！！使用from导致的好处仅仅是应用的时候不用加模块名字，执行的时候还是按原来的命名空间。

res：

from the spam.py
spam->read2 calling read
spam->read1->money 1000

from spam import money,read1,read2,change
import time
money=100 #跟spam.py 没关系，改的是当前文件中的money
print(money)
time.sleep(200) #在sleep的时间内，在另一个模块导入spam，打印spam.money,结果还是1000，所以证明了上面的结论
#
read1=10000000
from spam import read1
read1() #执行的是spam中的read1，因为函数名、变量名、模块名都是绑定关系，可以重新绑定

res：

from the spam.py
100

特殊的from spam import *（尽量少用）,这样可以导入所有模块，但是如果在spam.py中定义了__all__=['money']，则即使使用import * 导入的也只有money，即用__all__来控制import * 的结果是什么（__all__=['字符串1','字符串2'] =====》 *可以导入哪些）

 

模块的搜索顺序：
内存---->内置------->sys.path

import time
import spam
time.sleep(10) ##此时将spam.py删除
import spam as aa
print(aa.money)spam.py #这个也是可以打印结果的，因为spam已经加载到内存中了

包的介绍

###这块egon讲的比较深入，复制，深入了解，再看下视频（以下笔记部分来自于网上参考的博客）

目录结构示例：

Packages are a way of structuring Python’s module namespace by using “dotted module names”

包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

１. 无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法

2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）

3. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

glance/ #Top-level package

├── __init__.py #Initialize the glance package

├── api #Subpackage for api

│ ├── __init__.py

│ ├── policy.py

│ └── versions.py

├── cmd #Subpackage for cmd

│ ├── __init__.py

│ └── manage.py

└── db #Subpackage for db

├── __init__.py

└── models.py

 

#文件内容

#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)

2.1 注意事项
1.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。

2.对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。

3.对比import item 和from item import name的应用场景：
如果我们想直接使用name那必须使用后者。

2.2 import 

我们在与包glance同级别的文件中测试

import glance.db.models
glance.db.models.register_models('mysql')

2.3 from ... import ...

需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法

我们在与包glance同级别的文件中测试 

from glance.db import models
models.register_models('mysql')

from glance.db.models import register_models
register_models('mysql')

2.4 __init__.py文件

不管是哪种方式，只要是第一次导入包或者是包的任何其他部分，都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下)，这个文件可以为空，但是也可以存放一些初始化包的代码。

2.5  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仍然不能导入）。

2.6 绝对导入和相对导入

我们的最顶级包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同级的文件中测试

from glance.api import versions

注意：在使用pycharm时，有的情况会为你多做一些事情，这是软件相关的东西，会影响你对模块导入的理解，因而在测试时，一定要回到命令行去执行，模拟我们生产环境，你总不能拿着pycharm去上线代码吧！！！

 

特别需要注意的是：可以用import导入内置或者第三方模块（已经在sys.path中），但是要绝对避免使用import来导入自定义包的子模块(没有在sys.path中)，应该使用from... import ...的绝对或者相对导入,且包的相对导入只能用from的形式。

比如我们想在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,
这必然是找不到的
'''

2.7 单独导入包

单独导入包名称时不会导入包中所有包含的所有子模块，如

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

执行：

#在于glance同级的test.py中
import glance
glance.cmd.manage.main()

千万别问：__all__不能解决吗，__all__是用于控制from...import * ，fuck

 

补充：python垃圾回收机制

了解：

 

如上图，当一块内存地址的引用计数为0的时候，则被垃圾回收机制回收。

 

做有积累的事~~