Python之模块，迭代器与生成器

本节涉及内容：

　　　　1. 迭代器和生成器

　　　　2. 递归

　　　　3. 字符串格式化

　　　　4. 模块

　　　　　　内置模块

　　　　　　自定义模块

　　　　　　第三方模块

　　　　5. 序列化的模块

　　　　　　　　json

　　　　　　　　pickle

（一）. 迭代器和生成器：

　　　　　迭代器： 　　　　　　　

　　　　　　迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

　　特点：

1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
3. 访问到一半时不能往回退
4. 便于循环比较大的数据集合，节省内存

 >>> mylist = iter([1, 2, 3, 4, 5])
 >>> print(mylist.__next__())
 1
 >>> print(mylist.__next__())
 2
 >>> print(mylist.__next__())
 3
 >>> print(mylist.__next__())
 4
 >>> print(mylist.__next__())
 5
 >>> print(mylist.__next__())
 Traceback (most recent call last):
   File "<input>", line 1, in <module>
 StopIteration             

调用迭代器的__next__()方法循环执行每一条条目，条目全部取出后引发StopIteration异常(非错误)，表示迭代完成。

　　　　

　　　　生成器：

　　　　　　一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器；

 def func():   #func为一个函数称为生成器，
     print(1111)
     yield 1
     print(2222)
     yield 2
     print(3333)
     yield 3
 ret = func()   #执行func()函数时得到一个迭代器
 r1= ret.__next__()#进入函数找到yield，获取yield后边的数据
 print(r1)
 r2 = ret.__next__()
 print(r2)
 r3 = ret.__next__()
 print(r3)
 #输出：
 1111
 1
 2222
 2
 3333
 3

 def func():
     print(1111)
     yield 1
     print(2222)
     yield 2
     print(3333)
     yield 3
 ret = func()
 
 for i in ret:  #使用一个for循环可以简化手动的迭代
      print(i)
 #输出
 1111
 1
 2222
 2
 3333
 3

利用生成器自定义range

 def myrange(arg):
     start = 0
     while True:
         if start > arg:
             return
         yield start
         start += 1
 ret = myrange(3)
 r = ret.__next__()
 print(r)
 r = ret.__next__()
 print(r)
 r = ret.__next__()
 print(r)
 r = ret.__next__()
 print(r)
 #输出：
 0
 1
 2
 3

　　加强的生成器特性：

　　　　　　send(): 传入一个新的值。

　　　　　　close(): 抛出异常或者退出

 def counter(start = 0):
     count = start
     while True:
         val = (yield count)
         if val is not None:
             count = val
         else:
             count += 1
 count = counter(5)            #将函数传入值5
 print(count.__next__())             #通过next迭代每一个值
 print(count.__next__())
 count.send(8)               #通过send可以传入一个新的值来迭代
 print(count.__next__())
 print(count.__next__())
 count.close()               #close()函数则可以退出迭代
 print(count.__next__())     #再次调用就会出现StopIteration异常
 
 #输出：
 5
 6
 9
 10
 StopIteration

　　（二） 递归

　　　　　　如果一个新的调用能在相同过程中较早的调用结束之前开始，这个过程即为递归

 def func(n):
     n += 1
     if n >= 5:
         return 'end'
     return func(n)
 r = func(1)
 print(r)
 #输出：
 
 end

递归实现  1*2*3*4*5*6*7  的结果：

 def num(n):
     if n == 1:
         return 1
     else:
         return (n * num(n - 1))
 print(num(7))
 
 #输出：
 
 5040

　　（三）字符串格式化(引用)

　　　　　　两种方式：

　　　　　　　　1. 百分号(%)

　　　　　　　　2. format

　　　　　　百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。[PEP-3101]

　　　　1. 百分号(%)方式

%[(name)][flags][width].[precision]typecode

• (name)      可选，用于选择指定的key

• flags          可选，可供选择的值有:
  • +       右对齐；正数前加正好，负数前加负号；
  • -        左对齐；正数前无符号，负数前加负号；
  • 空格    右对齐；正数前加空格，负数前加负号；
  • 0        右对齐；正数前无符号，负数前加负号；用0填充空白处
• width         可选，占有宽度
• .precision   可选，小数点后保留的位数
• typecode    必选
  • s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
  • r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
  • c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
  • o，将整数转换成 八  进制表示，并将其格式化到指定位置
  • x，将整数转换成十六进制表示，并将其格式化到指定位置
  • d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
  • e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
  • E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
  • f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
  • F，同上
  • g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
  • G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
  • %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

　　注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

　　常用格式化：

 tpl = "i am %s" % "alex"
 
 tpl = "i am %s age %d" % ("alex", 18)
 
 tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
 
 tpl = "percent %.2f" % 99.97623
 
 tpl = "i am %(pp).2f" % {"pp": 123.425556, }
 
 tpl = "i am %.2f %%" % {"pp": 123.425556, }

　　

　　2. format方式

[[fill]align][sign][#][0][width][,][.precision][type]

• fill           【可选】空白处填充的字符
• align        【可选】对齐方式（需配合width使用）
• <，内容左对齐
• >，内容右对齐(默认)
• ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
• ^，内容居中
• sign         【可选】有无符号数字
  • +，正号加正，负号加负；
  •  -，正号不变，负号加负；
  • 空格 ，正号空格，负号加负；
• #            【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
• ，            【可选】为数字添加分隔符，如：1,000,000
• width       【可选】格式化位所占宽度
• .precision 【可选】小数位保留精度
• type         【可选】格式化类型
  • 传入” 字符串类型 “的参数
    • s，格式化字符串类型数据
    • 空白，未指定类型，则默认是None，同s
  • 传入“ 整数类型 ”的参数
    
    • b，将10进制整数自动转换成2进制表示然后格式化
    • c，将10进制整数自动转换为其对应的unicode字符
    • d，十进制整数
    • o，将10进制整数自动转换成8进制表示然后格式化；
    • x，将10进制整数自动转换成16进制表示然后格式化（小写x）
    • X，将10进制整数自动转换成16进制表示然后格式化（大写X）
  • 传入“ 浮点型或小数类型 ”的参数
    • e， 转换为科学计数法（小写e）表示，然后格式化；
    • E， 转换为科学计数法（大写E）表示，然后格式化;
    • f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
    • F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
    • g， 自动在e和f中切换
    • G， 自动在E和F中切换
    • %，显示百分比（默认显示小数点后6位）

　　常用格式化：

 tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
 
 tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
 
 tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
 
 tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
 
 tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
 
 tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
 
 tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
 
 tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
 
 tpl = "i am {:s}, age {:d}".format(*["seven", 18])
 
 tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
 
 tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
 
 tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 
 tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 
 tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
 
 tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

更多格式化操作：https://docs.python.org/3/library/string.html

　　（四）模块

　　　　　使大量的代码分成有组织的代码段，代码段可以彼此交互引用，增加了代码的重用性。

　　　　模块分为三种：

　　　　　　1. 内置模块

　　　　　　2. 自定义模块

　　　　　　3. 第三方模块

***导入模块***

　　1>使用import语句：

格式如下：

 import module1   #分行导入
 import  module2
         .....
 import module1,module2 #也可以在一行中导入多个模块，用逗号分隔            

 import sys
 improt os
 
 or 
 
 import sys,os

注意： import导入模块的顺序：

　　　1)内置模块

　　　2)第三方模块

　　　3)自定义模块

使用一个空行分割这三类模块的导入语句。模块在顶层导入时为全局作用域，在函数中导入时为局部作用域。

　　2> 使用from-import语句：

　　　　导入模块中的指定属性，将指定名称导入当前作用域

格式：

from module import name1[, name2[, nameN]]

from lib import commons

from Tkinter import (Tk, Frame, Button, Text)#按照规范多模块导入时加小括号
 
from Tkinter import *  #导入Tkinter下的所有模块

　　　3> 扩展的import语句（as）

 from lib import commons
 from var import commons  #两个模块名相同
 
 #针对这种情况可以使用：
 
 from lib import commons as  lib.commons
 from var import commons as  var.commons
 
 #之后直接导入模块：
 
 import lib.commons,var.commons

　　内置模块(引用)：

　　　　内置模块是Python自带的功能，在使用内置模块相应的功能时，需要【先导入】再【使用】

　　1. sys

用于提供对Python解释器相关的操作：

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

 import sys
 import time
 
 def view_bar(num, total):
     rate = float(num) / float(total)
     rate_num = int(rate * 100)
     r = '\r%d%%' % (rate_num, )
     sys.stdout.write(r)
     sys.stdout.flush()
 
 if __name__ == '__main__':
     for i in range(0, 100):
         time.sleep(0.1)
         view_bar(i, 100)
 
 进度百分比

　　2. os

用于提供系统级别的操作：

 os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
 os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
 os.curdir                   返回当前目录: ('.')
 os.pardir                   获取当前目录的父目录字符串名：('..')
 os.makedirs('dir1/dir2')    可生成多层递归目录
 os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname
 os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
 os.remove()                 删除一个文件
 os.rename("oldname","new")  重命名文件/目录
 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所指向的文件或者目录的最后修改时间

　　第三方模块：

　　　　在Python中，安装第三方模块，是通过setuptools这个工具完成的。Python有两个封装了setuptools的包管理工具：easy_install和pip。目前官方推荐使用pip。

pip3 install requests   #这里使用pip3的版本   

 import requests,json
 
 response = requests.get('http://wthrcdn.etouch.cn/weather_mini?city=北京')  #调取北京天气的借口
 response.encoding = 'utf-8' #设置字符编码
 dic = json.loads(response.text) #通过json序列化成一个字典
 print(dic,type(dic))
 
 print(response.status_code) #查看响应状态码
 
 #输出内容：
 
 {'status': 1000, 'data': {'ganmao': '相对于今天将会出现大幅度降温，易发生感冒，请注意适当增加衣服，加强自我防护避免感冒。', 'yesterday': {'fx': '无持续风向', 'high': '高温 30℃', 'fl': '微风', 'date': '5日星期日', 'type': '多云', 'low': '低温 18℃'}, 'wendu': '', 'forecast': [{'high': '高温 31℃', 'fengli': '微风级', 'fengxiang': '无持续风向', 'date': '6日星期一', 'type': '多云', 'low': '低温 19℃'}, {'high': '高温 24℃', 'fengli': '微风级', 'fengxiang': '无持续风向', 'date': '7日星期二', 'type': '雷阵雨', 'low': '低温 16℃'}, {'high': '高温 31℃', 'fengli': '微风级', 'fengxiang': '无持续风向', 'date': '8日星期三', 'type': '多云', 'low': '低温 20℃'}, {'high': '高温 32℃', 'fengli': '3-4级', 'fengxiang': '南风', 'date': '9日星期四', 'type': '晴', 'low': '低温 22℃'}, {'high': '高温 30℃', 'fengli': '微风级', 'fengxiang': '无持续风向', 'date': '10日星期五', 'type': '雷阵雨', 'low': '低温 20℃'}], 'aqi': '', 'city': '北京'}, 'desc': 'OK'} <class 'dict'>
 200   #状态码

　　自定义模块：　　　　

 #s1.py
 
 def login():
     print("login")
 
 def logout():
     print("logout")

 #s2.py
 
 import s1
 
 s1.login()
 s1.logout()
 
 #输出：
 login
 logout

　　（五） 序列化模块：

　　　　　　　json

　　　　　　   pickle

　　　json:

　　　　　dumps: 将Python的基本数据类型转换成字符串形式

　　　　　loads: 将Python字符串形式转换成可用数据类型

 import json
 
 # dumps
 # loads
 
 dic = {"k1":"v1"}
 print(dic,type(dic))
 result = json.dumps(dic)
 print(result,type(result))
 
 s1 = '{"k1": 123}'
 dic = json.loads(s1)  #通过loads反序列化时，一定要使用双引号“”
 print(dic,type(dic))
 
 #输出：
 {'k1': 'v1'} <class 'dict'>
 {"k1": "v1"} <class 'str'>
 {'k1': 123} <class 'dict'>

　　　dump #将json数据写入json文件里

　　　load   #将json文件里的数据读出来显示

 dump #将json数据写入json文件里
 load #将 json文件里的数据读出来显示
 
 import json
 #li = [11,22,33]
 li = {"hong":123,"fei":345} #定义字典
 print(type(li))
 json.dump(li,open('db','w')) #写入字典到json文件db
 li = json.load(open('db','r')) #读出db里内容
 print(type(li),li)
 
 #输出：
 <class 'dict'>
 <class 'dict'> {'hong': 123, 'fei': 345}
 #db内容：
16{"hong": 123, "fei": 345}

　　pickle模块：

　　　　与json类似，但只能用于Python，json则可以跨平台。

　　　　dumps

　　　　loads

import pickle
li = [11,22,33]
r = pickle.dumps(li)
print(r)
 
result = pickle.loads(r)
print(result)
#输出：
 
b'\x80\x03]q\x00(K\x0bK\x16K!e.'
[11, 22, 33]

　　dump

　　load

 import pickle
 
 li = [11,22,33]
 pickle.dump(li,open('db','wb'))
 result = pickle.load(open('db','rb'))
 print(result)
 
 #输出：
 [11, 22, 33]  #通过load读出来原格式
 #db文件内容：
 �]q (KKK!e.  无法识别的编码

　　

　　　　json与pickle的对比：

　　　　　　　json：更加适合跨语言，字符串，基本数据类型

　　　　　　　pickle：仅适用于Python ,Python的所有类型的序列化

　　

　　本节内容先总结到这里，新内容后续补充，谢谢查看！