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.超级管理员 \n>>>" )
         if inp == "":
             login()
         elif inp == "":
             home()
         elif inp == "":
             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下为"\t\n",Linux下为"\n"
 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。在软件开发初期，由于开发过程中以上内容可能不明确或者发生变化，并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候，是需要撰写这样的一个文档的。