4-python自动化-day04

本节内容

1. 迭代器&生成器
2. 装饰器
3. Json & pickle 数据序列化
4. 软件目录结构规范
5. 做业:ATM项目开发

转载：　　http://www.cnblogs.com/alex3714/articles/5765046.html

 

1、列表生成式，迭代器&生成器

列表生成式

孩子，我如今有个需求，看列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],我要求你把列表里的每一个值加1，你怎么实现？

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator:

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

迭代器

咱们已经知道，能够直接做用于for循环的数据类型有如下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些能够直接做用于for循环的对象统称为可迭代对象：Iterable。

可使用isinstance()判断一个对象是不是Iterable对象.

 

2、装饰器

 

装饰器(语法糖)的原则及构成：
三大原则：
一、不能修改被装饰函数的源代码。
二、不能修改被装饰函数的调用方式。
三、不能改变被装饰函数的执行结果。
装饰器对被装饰函数是透明的。

如何理解装饰器
一、函数即“变量”
二、高阶函数
a:把一个函数名做为实参传递给另一个函数
b:返回值中包含函数名
三、嵌套函数

在一个函数体内声明另外一个函数称为函数的嵌套

总结：三层函数

#_*_coding:utf-8_*_


user_status = False #用户登陆了就把这个改为True

def login(auth_type): #把要执行的模块从这里传进来
    def auth(func):
        def inner(*args,**kwargs):#再定义一层函数
            if auth_type == "qq":
                _username = "alex" #伪装这是DB里存的用户信息
                _password = "abc!23" #伪装这是DB里存的用户信息
                global user_status

                if user_status == False:
                    username = input("user:")
                    password = input("pasword:")

                    if username == _username and password == _password:
                        print("welcome login....")
                        user_status = True
                    else:
                        print("wrong username or password!")

                if user_status == True:
                    return func(*args,**kwargs) # 看这里看这里，只要验证经过了，就调用相应功能
            else:
                print("only support qq ")
        return inner #用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数

    return auth

def home():
    print("---首页----")

@login('qq')
def america():
    #login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

@login('weibo')
def henan(style):
    '''
    :param style: 喜欢看什么类型的，就传进来
    :return:
    '''
    #login() #执行前加上验证
    print("----河南专区----")

home()
# america = login(america) #你在这里至关于把america这个函数替换了
#henan = login(henan)

# #那用户调用时依然写
america()

# henan("3p")

View Code

 

3.Json & pickle 数据序列化

参考 http://www.cnblogs.com/alex3714/articles/5161349.html

 

　　

4.软件目录结构规范

为何要设计好目录结构?

"设计项目目录结构"，就和"代码编码风格"同样，属于我的风格问题。对于这种风格上的规范，一直都存在两种态度:

1. 一类同窗认为，这种我的风格问题"可有可无"。理由是能让程序work就好，风格问题根本不是问题。
2. 另外一类同窗认为，规范化能更好的控制程序结构，让程序具备更高的可读性。

我是比较偏向于后者的，由于我是前一类同窗思想行为下的直接受害者。我曾经维护过一个很是很差读的项目，其实现的逻辑并不复杂，可是却耗费了我很是长的时间去理解它想表达的意思。今后我我的对于提升项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴，咱们设计一个层次清晰的目录结构，就是为了达到如下两点:

1. 可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪一个，测试目录在哪儿，配置文件在哪儿等等。从而很是快速的了解这个项目。
2. 可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪一个文件和代码应该放在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增长，项目结构不会混乱，仍然可以组织良好。

因此，我认为，保持一个层次清晰的目录结构是有必要的。更况且组织一个良好的工程目录，实际上是一件很简单的事儿。

目录组织方式

关于如何组织一个较好的Python工程目录结构，已经有一些获得了共识的目录结构。在Stackoverflow的这个问题上，能看到你们对Python目录结构的讨论。

这里面说的已经很好了，我也不打算从新造轮子列举各类不一样的方式，这里面我说一下个人理解和体会。

假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

简要解释一下:

1. bin/: 存放项目的一些可执行文件，固然你能够起名script/之类的也行。
2. foo/: 存放项目的全部源代码。(1) 源代码中的全部模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码； (3) 程序的入口最好命名为main.py。
3. docs/: 存放一些文档。
4. setup.py: 安装、部署、打包的脚本。
5. requirements.txt: 存放软件依赖的外部Python包列表。
6. README: 项目说明文件。