Python基础知识学习_Day5

一、生成器和迭代器

1.列表生成

>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = map(lambda x:x+1, a)
>>> a
<map object at 0x101d2c630>
>>> for i in a:print(i)
... 
3
5
7
9
11

或者


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

data = [1,2,3,4,5,6,7,8]
r = [i*2 if i>4 else i for i in data]
print(r)

2.创建生成器　　

生成器作用是不占用空间，使用哪一个调用即可，不使用就不调用。

>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
...
0
1
4
9
16
25
36
49
64
81

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

def fib(num):
    count = 0
    a,b = 0,1
    while count<num:
        a,b = b,a+b
     
        count+=1
        yield a      #yield表示返回a  但不会终止
    print("done....")
f = fib(10)
for i in f:print(i)

generator和函数的执行流程的区别：函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

我们基本不会用next()来获取下一个返回值，而是直接使用for循环来迭代

3.利用生成器实现单线程并发运算

def consumer(name):
    print("%s 准备吃包子啦!"%name)
    while True:
        baozi=yield
        print("包子[%s]来了,被[%s]吃了" %(baozi,name))

def producer(name):
    c=consumer("A")
    c2=consumer("B")
    c.__next__()
    c2.__next__()
    print("老子开始做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子")
        c.send(i)
        c2.send(i)
producer("alex")

4.迭代器

可以直接用作for循环的对象统称可迭代对象：Iterable

可以使用isinstance()判断一个对象是否是Iterable对象：

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

总结：

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

二、装饰器

要求不改变原代码的情况下，遵循开放-封闭原则，对原函数进行包装扩展功能。

核心：1.@+函数 会自动执行@函数，并将被装饰的函数作为参数传递。
         2.将@函数的返回值重新赋值给被装饰的函数。

user_status = False  # 用户登录了就把这个改成True
def login(func):  # 把要执行的模块从这里传进来
    def inner(*args, **kwargs):  # 再定义一层函数
        _username = "alex"  # 假装这是DB里存的用户信息
        _password = "abc123"  # 假装这是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:
            func(*args, **kwargs)  # 看这里看这里，只要验证通过了，就调用相应功能
    return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数
def home():
    print("---首页----")
@login
def america():
    print("----欧美专区----")
def japan():
    print("----日韩专区----")
# @login
def henan(style):
    print("----河南专区----")
home()
america()
japan()
henan("3p")

 通过装饰器权限控制的实例

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Liumj
USER_INFO = {}
def check_login(func):
    def inner(*args,**kwargs):
        if USER_INFO.get('is_login'):
            ret = func(*args,**kwargs)
            return ret
        else:
            print("请登录")
    return inner
def check_admin(func):
    def inner(*args,**kwargs):
        if USER_INFO.get('user_type') == 2:
            ret = func(*args,**kwargs)
            return ret
        else:
            print("无权查看")
    return inner
@check_admin
@check_login
def index():
    print('Index')
@check_login
def home():
    print('home')
    
def login():
    user = input('请输入用户名:')
    if user == 'admin':
        USER_INFO['is_login'] = True
        USER_INFO['user_type'] = 2
        print("超级管理员登陆成功!")
    else:
        USER_INFO['is_login'] = True
        USER_INFO['user_type'] = 1


def main():
    while True:
        inp = input("1,登陆: 2.查看信息: 3.超级管理员 
>>>" )
        if inp == "1":
            login()
        elif inp == "2":
            home()
        elif inp == "3":
            index()
main()

三、常用模块

n个 .py 文件组成的代码集合就称为模块。

模块分为：内置模块(标准库)、自定义模块、开源模块

1.OS模块

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"	
",Linux下为"
"
os.pathsep    输出用于分割文件路径的字符串
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.environ  获取系统环境变量
os.path.abspath(path)  返回path规范化的绝对路径
os.path.split(path)  将path分割成目录和文件名二元组返回
os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

2.sys模块

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
 

四、序列化和反序列化

json,用于字符串和python数据类型之间的转换

pickle,用于python特有的类型和python的数据类型之间进行转换

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

实例用法

import json
data = {
    "name":"alex",
    "age":22,
    "sex":"M"
}
f = open("data.txt","w",encoding="utf-8")
#f.write(json.dumps(data))  #dumps用法
json.dump(data,f)    #dump用法
f.close()



import json
f = open("data.txt",encoding="utf-8")
#d = json.loads(f.read())   #loads用法
d = json.load(f)    #load用法
print(d,type(d))

 四、开发规范

设计好目录结构

优点：

可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个，测试目录在哪儿，配置文件在哪儿等等。从而非常快速的了解这个项目。

可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，仍然能够组织良好。

目录组织方式：

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: 项目说明文件。

readme 目的是能简要描述该项目的信息，让读者快速了解这个项目。

它需要说明以下几个事项:

1. 软件定位，软件的基本功能。
2. 运行代码的方法: 安装环境、启动命令等。
3. 简要的使用说明。
4. 代码目录结构说明，更详细点可以说明软件的基本原理。
5. 常见问题说明。

我觉得有以上几点是比较好的一个README。在软件开发初期，由于开发过程中以上内容可能不明确或者发生变化，并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候，是需要撰写这样的一个文档的。