Day5 函数递归，匿名、内置行数，模块和包，开发规范

一、递归与二分法

一、递归

　　1、递归调用的定义

　　递归调用：在调用一个函数的过程中，直接或间接地调用了函数本身

　　2、递归分为两类：直接与间接

#直接
def func():
    print('from func')
    func()

func()
# 间接
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')
    foo()

foo()

　　3、递归调用的特点和使用的注意点

递归调用：在调用一个函数的过程中，直接或间接地调用了函数本身
python中的递归效率低，需要在进入下一次递归时保留当前的状态
在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化：http://egon09.blog.51cto.com/9161406/1842475；但是python又没有尾递归，且对递归层级做了限制

#总结递归的使用：
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出
在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

　　4、递归的执行分为两个阶段：递推（询问的过程）和回溯（回答的过程）

 #获知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(1)=18 #n=1

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

 print(age(5))

　　5、可以递归的最大深度

 #虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归
 import sys
 sys.getrecursionlimit()  ##获取目前默认递归的最大深度，默认深度是1000
 sys.setrecursionlimit(500)  ##更改默认递归的最大深度
 n=1
 def test():
     global n
     print(n)
     n+=1
     test()
 test()

　　6、应用场景：有许多层的列表，要取出所有元素——设置结束条件使用递归

l =[1, 2,'list' ,[3, [4, 5, 6, [7, 8, [9, 10, [11, 12, 13, [14, 15,[16,[17,]],19]]]]]]]
def search(l):
    for item in l:
        # if type(item) is list:
        if isinstance(item,list): ##判断数据类型是否是列表
            search(item)
        else:
            print(item)

search(l)

二、二分法

　　1、二分法的产生

一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模

　　2、 二分法的作用：不断将列表切分成两份，减小压力

 l = [1,2,5,6,77,1001,1165,2340]
 def search(l,num):
     print(l)
     if len(l) > 1:
         mid_index = len(l) // 2 #相除取整
         if num > l[mid_index]:
             #in the right
             l = l[mid_index+1:]
         elif num < l[mid_index]:
             #in the left
             l = l[:mid_index]
         else:
             print('find it')
             return
     else:
         if l[0] == num:
             print('find it')
         else:
             print('not exists')
         return
     search(l,num)
 search(l,77)

二、匿名函数

一、什么是匿名函数

# 有名函数
def f1(m):
print(f1(3))
# 匿名函数
lambda n:n*2

二、匿名函数的应用场景

匿名函数自带return,只能使用一次
#匿名函数即没有绑定名字的函数，意味着只能使用一次就会回收
应用场景：只使用一次的功能

三、匿名函数的使用

salaries={
    'egon':3000,
    'alex':10000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

def f1(k):
    return salaries[k]

　　1、max、min与 lambda结合

print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))

　　2、sorted与lambda结合

print(sorted(salaries,key=lambda k:salaries[k]))
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

　　3、map（映射）与lambda结合

　　将原来的元素进行处理后，重新赋值给原变量

l=['alex','egon','wzs','yuanhao']
print(list(map(lambda x:x+'',l)))

　　4、reduce（合并）与lambda结合

　　计算0到100数字的和

 from functools import reduce
 # reduce(lambda 表达式,计算范围,计算的初始值)
 res=reduce(lambda x,y:x+y,range(1,100),100)
 print(res)

　　5、filter（过滤）与lambda结合

　　过滤出列表中以123结尾的元素

l=['alex123','egon123','wzs123','yuanhao']
print(list(filter(lambda name:name.endswith(''),l)))

　　6、扩展： 拉链函数

l1=[1,2,3]
s1='hello'
res = zip(l1,s1)
print(list(res))

res=zip(salaries.values(),salaries.keys())
print(max(res)[1])

 t1=(111,'a')
 t2=(11,'b',123,'c')
 print(t1 < t2)

元素比较大小：从左到右比较元素的大小

三、内置函数

一、什么是内置函数

内置函数：python将简单的功能内置到语言中，使用者不用定义，可以直接使用
内置函数链接：https://docs.python.org/3/library/functions.html?highlight=built#ascii

二、常用的内置函数

　　

　　友情链接：http://www.cnblogs.com/xiao1/p/5856890.html

　　1、优先掌握的函数

max min sorted map filter sum bool chr divmod enumerate
id input print isinstance iter len open pow type zip
from _functools import reduce

　　2、数学运算

abs(-5)                          # 取绝对值，也就是5
round(2.6)                       # 四舍五入取整，也就是3.0
pow(2, 3)                        # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5
cmp(2.3, 3.2)                    # 比较两个数的大小
divmod(9,2)                      # 返回除法结果和余数，分页显示内容，计算页数
max([1,5,2,9]) # 求最大值 min([9,2,-4,2]) # 求最小值 sum([2,-1,9,12]) # 求和

　　3、类型转换

int("")                         # 转换为整数 integer
float(2)                         # 转换为浮点数 float
long("")                       # 转换为长整数 long integer
str(2.3)                         # 转换为字符串 string
complex(3, 9)                    # 返回复数 3 + 9i
bytes()                          # 字节
list((1,2,3))                    # 转换为表 list
tuple([2,3,4])                   # 转换为定值表 tuple
dict(a=1,b="hello",c=[1,2,3])    # 构建词典 dictionary
set()                            # 转换成集合
slice(5,2,-1)                    # 切片操作

 # bytes object
 b = b"example"
 # str object
 s = "example"
 # str to bytes
 sb = bytes(s, encoding = "utf8")
 print(type(sb))
 # bytes to str
 bs = str(b, encoding = "utf8")
 # an alternative（可替代的方法） method
 # str to bytes
 sb2 = str.encode(s)
 # bytes to str
 bs2 = bytes.decode(b)

python str与bytes之间的转换

　　ASCII表中的字符和序号之间互相转好，应用场景：生成随机验证码

#65-90是大写A-Z
print(chr(65))
print(chr(90))
#97-122是小写a-z
print(chr(97))
print(chr(122))
print(ord('A'))
#48-57是数字0-9
print(chr(48))
print(chr(57))

　　bool()布尔判断，在python中，为False的情况：空（字符 ‘’，列表 []，元组 ()，字典 {}），0，0.0，None

bool(0)                          # 转换为相应的真假值，在Python中，0相当于False

　　进制显示

bin(56)                          # 返回一个字符串，表示56的二进制数
hex(56)                          # 返回一个字符串，表示56的十六进制数
oct(56)                          # 返回一个字符串，表示56的八进制数

　　判断元素是否为True

all([True, 1, "hello!"])         # 是否所有的元素都相当于True值
any(["", 0, False, [], None])    # 是否有任意一个元素相当于True值

　　排序

sorted([1,5,3])                  # 返回正序的序列，也就是[1,3,5]
reversed([1,5,3])                # 返回反序的序列，也就是[3,5,1]

　　4、类、对象、属性

# define class
class Me(object):
    def test(self):
        print "Hello!"
def new_test():
    print "New Hello!"
me = Me()

object()
hasattr(me, "test")               # 检查me对象是否有test属性
getattr(me, "test")               # 返回test属性
setattr(me, "test", new_test)     # 将test属性设置为new_test
delattr(me, "test")               # 删除test属性
isinstance(1,int)                 # 检查对象是否是类的对象，返回True或False
issubclass(Me, object)            # Me类是否为object类的子类

　　5、hash哈希值 ：应用——数据校验

hash(object)
如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。
两个数值如果相等，则哈希值也相等。

　　6、名称空间 局部名称vars()、locals()，全局名称空间global()，显示形式是字典

print(vars() is locals())
print(globals())

　　7、__import__()  可以导入字符串，import不能导入字符串

# import "time" #不能导入字符串
# import time
m=input('>>:')
print(type(m))
obj=__import__(m)  ##这样就可以导入字符串了
obj.sleep(2)
print(m)

　　8、compile编译，执行exec、eval （了解）

　　　　1、compile编译

　　语法

compile(str,filename,kind)
filename:用于追踪str来自于哪个文件，如果不想追踪就可以不定义
kind可以是：single代表一条语句，exec代表一组语句，eval代表一个表达式

　　应用

s="for i in range(10):print(i)"
code=compile(s,'','exec')
exec(code)  ##有返回结果

s1="1+2+3"
code1=compile(s1,'','eval')
eval(code1) ##没有返回结果

　　　　2、eval与exec

　　eval 提取字符串内的表达式执行，并返回结果（可执行语句会报错）
　　exec 执行字符串内的表达式或语句，没有返回结果

　　语法

eval(str,[,globals[,locals]])
exec(str,[,globals[,locals]])

　　举例

 s1="1+2+3"
 # s1="['a','b','c']"
 s2="for i in range(10):print (i)"
 print(eval(s1))
 print(exec(s1))
 print(exec(s2))

四、模块

一、模块介绍

　　1、什么是模块

一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

　　2、为何使用模块

如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。
      随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

　　import加载的模块分为四个通用类别

1、使用python编写的代码（.py文件）
2、已被编译为共享库或DLL的C或C++扩展
3、好一组模块的包
4、使用C编写并链接到python解释器的内置模块

　　3、导入模块都干了哪些事？

1、执行源文件
2、以一个源文件的全局名称空间
3、在当前位置拿到一个模块名，指向2创建的名称空间

　　4、python文件的两种用途

.py文件的两种用途：1、当做脚本运行 2、当做模块被加载运行

文件当做脚本运行时，__name__等于__main__
文件当做模块被加载运行时，__name__等于模块名

if __name__ == '__main__':
    # 当做脚本使用
    func1()
    func2()
    func3()
# main  #回车会导入if __name__ == '__main__':

二、使用import导入模块

　　模块代码文件：spam.py

#spam.py
# print('from the spam.py')
# 限制*的导入内容
# _money=1000 #对*隐藏，即*无法调用（from spam import *）
# __all__ = ['money','x'] # *只能调用赋予给__all__的名称 （from spam import *）
money=10000000000000
def read1():
    print('spam->read1->money',money)

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

def change():
    global money
    money=0

　　1、导入模块并执行

　　test.py

import spam
money=100
spam.read1()
spam.read2()
spam.change()
spam.read1()
print(money)

　　2、as取别名

　　　　用途：1、模块名非常长； 2、更改模块的功能

　　测试文件

 def sqlparse():
     print('mysql sqlparse')

mysql.py

 def sqlparse():
     print('oracle sqlparse')

oracle.py

　　导入模块，并执行

 import spam as s1
 money = 10000000
 spam.change()
 print(spam.money)

模块名比较长

 sql_type = input('sql_type>>')
 if sql_type == 'mysql':
     import mysql as sql  ##引用不同的模块，因为实现的功能是相同的，所以可以起相同的别名
 elif sql_type == 'oracle':
     import oracle as sql
 sql.sqlparse()

传入的内容调用不同的模块

　　3、导入多个模块：模块之间用逗号隔开（不建议这么写，还是不同模块分行写为好）

import os,sys,requests

　　4、模块导入的特点

　　模块只在第一次导入时才会执行，之后的导入都是直接引用内存已经存在的结果

 import spam
 import spam
 import spam
 import spam

 #验证是否已经在内存
 import sys
 # print(sys.modules) #存放的是已经加到内存的模块
 print('spam' in sys.modules)   #查看一个模块是否加到内存中
 import spam
 print('spam' in sys.modules)

导入，并验证是否已在内存中

三、from....import...导入模块

　　1、对比import导入模块，from....import...的优缺点

 对比import spam，会将源文件的名称空间'spam'带到当前名称空间中，使用时必须是spam.名字的方式
 而from 语句相当于import，也会创建新的名称空间，但是将spam中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以了
 优点：使用源文件内的名字时，无需加前缀，使用方便
 缺点：容易与当前文件的名称空间内的名字混淆,会覆盖原来名字的值

　　2、语法范例

 from spam import money,read1,read2
 money = 10
 print(money)
 # g=read1()
 g=read2()
 print(g)

　　3、将模块导入并起别名

# # from spam import read1 as m
from spam import money as m
# print(m)

　　4、*的使用  （不建议使用*）

#要引用的源文件里面的内容很多时，可以使用*代替所有（更容易与当前文件的名称空间冲突），但是不建议使用

_money=1000 #将调用的名字前面加_，*就无法调用该名字（在源文件修改）
__all__ = ['money','x'] # *只能调用赋予给__all__的名称（在源文件修改）
from spam import *

四、模块的搜索路径

　　1、模块查找的顺序

查找顺序：内存---->>内置模块---->>硬盘

　　范例

import time
import importlib
import spam
time.sleep(30)
# import spam
# print(spam.money)

importlib.reload(spam)  ##重启加载spam，可以使用到测试环境
print(spam.money)

　　2、模块的注意事项

注意：
    1、Python程序只有重新加载才能生效
    2、Python自带的模块名不能使用

　　3、搜索路径和注意事项

当一个命名为spam的模块被导入时
    解释器首先会从内建模块中寻找该名字
    找不到，则去sys.path中找该名字
sys.path从以下位置初始化
    1 执行文件所在的当前目录
    2 PTYHONPATH（包含一系列目录名，与shell变量PATH语法一样）
    3 依赖安装时默认指定的
注意：在支持软连接的文件系统中，执行脚本所在的目录是在软连接之后被计算的，换句话说，包含软连接的目录不会被添加到模块的搜索路径中
在初始化后，我们也可以在python程序中修改sys.path,执行文件所在的路径默认是sys.path的第一个目录，在所有标准库路径的前面。这意味着，当前目录是优先于标准库目录的，需要强调的是：我们自定义的模块名不要跟python标准库的模块名重复

　　4、添加到path环境变量

import sys
print(sys.path)
# 添加path环境变量
# 加到最后面
sys.path.append(r'G:\data\PyCharm_Project\s19\day5\模块\模块的搜索路径\aaa')
# 加到最前面
sys.path.insert(0,r'G:\data\PyCharm_Project\s19\day5\模块\模块的搜索路径\aaa')

import spam

from aaa import #模块的搜索路径

五、模块的重载

　　考虑到性能的原因，每个模块只被导入一次,放入字典sys.module中，如果你改变了模块的内容，你必须重启程序，python不支持重新加载或卸载之前导入的模块

　　有的同学可能会想到直接从sys.module中删除一个模块不就可以卸载了吗，注意了，你删了sys.module中的模块对象仍然可能被其他程序的组件所引用，因而不会被清楚。

　　特别的对于我们引用了这个模块中的一个类，用这个类产生了很多对象，因而这些对象都有关于这个模块的引用。

　　如果只是你想交互测试的一个模块，使用 importlib.reload(), e.g. import importlib; importlib.reload(modulename)，这只能用于测试环境。

 def func1():
     print('func1')

aa.py

 import time,importlib
 import aa

 time.sleep(20)
 # importlib.reload(aa)
 aa.func1()

reload.py

五、包

　　http://www.cnblogs.com/linhaifeng/articles/6379069.html

一、包的简介

　　1、什么是包

##官网的解释
包是一种通过使用‘.模块名’来组织Python模块名称空间的方式
##详细解释
包就是一个含有__init__.py文件的文件夹，所以我们创建包的目的就是为了用文件/模块组织起来。
1. 无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法
2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）
3. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件
##强调：
　　1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
　　2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包即模块
包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

　　2、为何要使用包

随着功能越写越多，我们无法将所有功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们需要用文件夹将模块文件组织起来，依次来提供程序的结构性和可维护性

　　3、注意事项

.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。
.对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
.对比import item 和from item import name的应用场景：
如果我们想直接使用name那必须使用后者。

　　4、上课流程

实验一
    准备：
        执行文件为test.py，内容
        #test.py
        import aaa
        同级目录下创建目录aaa,然后自建空__init__.py(或者干脆建包)

    需求：验证导入包就是在导入包下的__init__.py

    解决：
        先执行看结果
        再在__init__.py添加打印信息后，重新执行

2、实验二
    准备：基于上面的结果

    需求：
        aaa.x
        aaa.y
    解决：在__init__.py中定义名字x和y

3、实验三
    准备：在aaa下建立m1.py和m2.py
        #m1.py
        def f1():
            print('from 1')
        #m2.py
        def f2():
            print('from 2')
    需求：
        aaa.m1 #进而aaa.m1.func1()
        aaa.m2 #进而aaa.m2.func2()

    解决：在__init__.py中定义名字m1和m2,先定义一个普通变量，再引出如何导入模块名，强调:环境变量是以执行文件为准

4、实验四
    准备：在aaa下新建包bbb

    需求：
        aaa.bbb

    解决：在aaa的__init__.py内导入名字bbb

5、实验五
    准备：
        在bbb下建立模块m3.py
        #m3.py
        def f3():
            print('from 3')
    需求：
        aaa.bbb.m3 #进而aaa.bbb.m3.f3()

    解决：是bbb下的名字m3，因而要在bbb的__init__.py文件中导入名字m3，from aaa.bbb import m3

6、实验六
    准备：基于上面的结果

    需求:
        aaa.m1()
        aaa.m2()
        aaa.m3()
        进而实现
        aaa.f1()
        aaa.f2()
        aaa.f3()
        先用绝对导入，再用相对导入

    解决：在aaa的__init__.py中拿到名字m1、m2、m3
    包内模块直接的相对导入，强调包的本质：包内的模块是用来被导入的，而不是被执行的
    用户无法区分模块是文件还是一个包，我们定义包是为了方便开发者维护

7、实验七
    将包整理当做一个模块，移动到别的目录下，操作sys.path

二、包的使用

　　1、测试文件：执行文件与测试文件在同级目录下

包
├── aaa
│   ├── bbb
│   │   ├── __init__.py
│   │   ├── m3.py
│   │   └── __pycache__
│   ├── __init__.py
│   ├── m1.py
│   ├── m2.py
│   └── __pycache__
└── run.py

##文件内容

#m1.py
def func1():
    print('f1')

#m2.py
def func2():
    print('f2')

#m3.py
def func3():
    print('f3')

文件内容

　　2、包的使用之import

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

#在与aaa同级的run.py
import aaa
aaa.m1.func1()

执行结果会出现如下错误：
ModuleNotFoundError: No module named 'm1'

　　解决方法

#与aaa底下的__init__.py
from .m1 import func1

#导入模块，执行aaa同级的run.py的结果
import aaa

f1

　　需要注意的：

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

　　　　from aaa.bbb.m3 import func3

　　3、from aaa.bbb.m3 import * ：从一个包中导入所有*

　想从包api中导入所有，实际上该语句只会导入包api下__init__.py文件中定义的名字，我们可以在这个文件中定义__all___:

#在__init__.py中定义
x=10

def func():
    print('from api.__init.py')

__all__=['x','func','policy']

　　4、绝对导入和相对导入

　　最*包是aaa是给用户使用的，然后在aaa内部也会有彼此之间相互导入的需求，这时就有绝对和相对导入两种方式。

　　绝对导入：以aaa作为起始

　　相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

　　

　　　例：想在aaa/bbb/func3.py中导入aaa/ccc/func4.py

    绝对导入
        在func3.py上写入下面的代码
from aaa.ccc.m4 import func4
        与run.py同级的__init__.pyd导入相应的模块
from aaa.bbb.m3 import func4
        在run.py上的写入下面的代码直接调用
aaa.func4()

    相对导入
        在func4.py上写入下面的代码
from ..ccc.m4 import func4
        与run.py同级的__init__.pyd导入相应的模块
from aaa.bbb.m3 import func4
        在run.py上的写入下面的代码直接调用
aaa.func4()

　　5、包以及包所包含的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的

　　添加环境变量

import sys
sys.path.append(r'C:\Users\CTB-BJB-0012\PycharmProjects\python36\s19\day5\包\xxx\yyy')
import aaa

 from .m1 import func1
 from .m2 import func2
 from .bbb.m3 import func3
 from .bbb.m3 import func4

aaa同级的__init__.py内容

 from ..ccc.m4 import func4
 def func3():
     print('f3')
     func4()

m3.py文件内容

 import sys
 sys.path.append(r'C:\Users\CTB-BJB-0012\PycharmProjects\python36\s19\day5\包\xxx\yyy')
 import aaa
 aaa.func1()
 aaa.func2()
 aaa.func3()

运行run.py文件内容

　　运行文件使用import直接导入所需模块的功能（使用了解目录结构）：

　　　　导入：import aaa.ccc.m4

　　　　调用：aaa.ccc.c4.func4()

　　6、包的分发（了解）

　　学习链接网址：https://packaging.python.org/tutorials/distributing-packages/

六、软件开发规范

一、软件目录规范如下

　　

二、常用模块的使用

 #=============>bin目录：存放执行脚本
 #start.py
 import sys,os

 BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.append(BASE_DIR)

 from core import core
 from conf import my_log_settings

 if __name__ == '__main__':
     my_log_settings.load_my_logging_cfg()
     core.run()

 #=============>conf目录：存放配置文件
 #config.ini
 [DEFAULT]
 user_timeout = 1000

 [egon]
 password = 123
 money = 10000000

 [alex]
 password = alex3714
 money=10000000000

 [yuanhao]
 password = ysb123
 money=10

 #settings.py
 import os
 config_path=r'%s\%s' %(os.path.dirname(os.path.abspath(__file__)),'config.ini')
 user_timeout=10
 user_db_path=r'%s\%s' %(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),\
                      'db')

 #my_log_settings.py
 """
 logging配置
 """

 import os
 import logging.config

 # 定义三种日志输出格式 开始

 standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                   '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

 simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

 id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

 # 定义日志输出格式 结束

 logfile_dir = r'%s\log' %os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # log文件的目录

 logfile_name = 'all2.log'  # log文件名

 # 如果不存在定义的日志目录就创建一个
 if not os.path.isdir(logfile_dir):
     os.mkdir(logfile_dir)

 # log文件的全路径
 logfile_path = os.path.join(logfile_dir, logfile_name)

 # log配置字典
 LOGGING_DIC = {
     'version': 1,
     'disable_existing_loggers': False,
     'formatters': {
         'standard': {
             'format': standard_format
         },
         'simple': {
             'format': simple_format
         },
     },
     'filters': {},
     'handlers': {
         #打印到终端的日志
         'console': {
             'level': 'DEBUG',
             'class': 'logging.StreamHandler',  # 打印到屏幕
             'formatter': 'simple'
         },
         #打印到文件的日志,收集info及以上的日志
         'default': {
             'level': 'DEBUG',
             'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
             'formatter': 'standard',
             'filename': logfile_path,  # 日志文件
             'maxBytes': 1024*1024*5,  # 日志大小 5M
             'backupCount': 5,
             'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
         },
     },
     'loggers': {
         #logging.getLogger(__name__)拿到的logger配置
         '': {
             'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
             'level': 'DEBUG',
             'propagate': True,  # 向上（更高level的logger）传递
         },
     },
 }

 def load_my_logging_cfg():
     logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
     logger = logging.getLogger(__name__)  # 生成一个log实例
     logger.info('It works!')  # 记录该文件的运行状态

 if __name__ == '__main__':
     load_my_logging_cfg()

 #=============>core目录：存放核心逻辑
 #core.py
 import logging
 import time
 from conf import settings
 from lib import read_ini

 config=read_ini.read(settings.config_path)
 logger=logging.getLogger(__name__)

 current_user={'user':None,'login_time':None,'timeout':int(settings.user_timeout)}
 def auth(func):
     def wrapper(*args,**kwargs):
         if current_user['user']:
             interval=time.time()-current_user['login_time']
             if interval < current_user['timeout']:
                 return func(*args,**kwargs)
         name = input('name>>: ')
         password = input('password>>: ')
         if config.has_section(name):
             if password == config.get(name,'password'):
                 logger.info('登录成功')
                 current_user['user']=name
                 current_user['login_time']=time.time()
                 return func(*args,**kwargs)
         else:
             logger.error('用户名不存在')

     return wrapper

 @auth
 def buy():
     print('buy...')

 @auth
 def run():

     print('''
 购物
 查看余额
 转账
     ''')
     while True:
         choice = input('>>: ').strip()
         if not choice:continue
         if choice == '':
             buy()

 if __name__ == '__main__':
     run()

 #=============>db目录：存放数据库文件
 #alex_json
 #egon_json

 #=============>lib目录：存放自定义的模块与包
 #read_ini.py
 import configparser
 def read(config_file):
     config=configparser.ConfigParser()
     config.read(config_file)
     return config

 #=============>log目录：存放日志
 #all2.log
 [2017-07-29 00:31:40,272][MainThread:11692][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
 [2017-07-29 00:31:41,789][MainThread:11692][task_id:core.core][core.py:25][ERROR][用户名不存在]
 [2017-07-29 00:31:46,394][MainThread:12348][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
 [2017-07-29 00:31:47,629][MainThread:12348][task_id:core.core][core.py:25][ERROR][用户名不存在]
 [2017-07-29 00:31:57,912][MainThread:10528][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
 [2017-07-29 00:32:03,340][MainThread:12744][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
 [2017-07-29 00:32:05,065][MainThread:12916][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
 [2017-07-29 00:32:08,181][MainThread:12916][task_id:core.core][core.py:25][ERROR][用户名不存在]
 [2017-07-29 00:32:13,638][MainThread:7220][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
 [2017-07-29 00:32:23,005][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
 [2017-07-29 00:32:40,941][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
 [2017-07-29 00:32:47,222][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
 [2017-07-29 00:32:51,949][MainThread:7220][task_id:core.core][core.py:25][ERROR][用户名不存在]
 [2017-07-29 00:33:00,213][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
 [2017-07-29 00:33:50,118][MainThread:8500][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
 [2017-07-29 00:33:55,845][MainThread:8500][task_id:core.core][core.py:20][INFO][登录成功]
 [2017-07-29 00:34:06,837][MainThread:8500][task_id:core.core][core.py:25][ERROR][用户名不存在]
 [2017-07-29 00:34:09,405][MainThread:8500][task_id:core.core][core.py:25][ERROR][用户名不存在]
 [2017-07-29 00:34:10,645][MainThread:8500][task_id:core.core][core.py:25][ERROR][用户名不存在]

常用模块的使用