python学习之旅_第2天

学习目标：

三天掌握 python 入门知识

---

学习内容：

1、 Python3 迭代器与生成器
2、 Python3 函数
3、 Python3 数据结构
4、 Python3 模块
5、 Python3 输入和输出
6、 Python3 File(文件) 方法
7、 Python3 OS 文件/目录方法
8、 Python3 错误和异常
9、 Python3 面向对象
10、Python3 命名空间和作用域
11、Python3 标准库概览
12、Python3 实例

---

学习时间：

周六至周日上午 7 点—晚上9点

---

学习产出：

1、 技术笔记 1 遍
2、CSDN 技术博客 3 篇
3、 学习的 vlog 视频 3 个

学习笔记：

• 1、 Python3 迭代器与生成器

  迭代器

   迭代是Python最强大的功能之一，是访问集合元素的一种方式。
  

  ​ 迭代器是一个可以记住遍历的位置的对象。

  ​ 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。

  ​ 迭代器只能往前不会后退。

  ​ 迭代器有两个基本的方法：iter() 和 next()。

  ​ 字符串，列表或元组对象都可用于创建迭代器：

  创建一个迭代器
  

  ​ 把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。

  	面向对象编程，类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。
  

  ​ 更多内容查阅：Python3 面向对象

  __iter__() 方法返回一个特殊的迭代器对象，实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
  

  __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
  

  StopIteration
  StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
  

  生成器

  在 Python 中，使用了 yield 的函数被称为生成器（generator）。

  跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

  在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

  调用一个生成器函数，返回的是一个迭代器对象。

   实例使用 yield 实现斐波那契数列 :
   
  import sys
  def fibonacci(n): # 生成器函数 - 斐波那契
      a, b, counter = 0, 1, 0
      while True:
          if (counter > n): 
              return
          yield a
          a, b = b, a + b
          counter += 1
  f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
   
  while True:
      try:
          print (next(f), end=" ")
      except StopIteration:
          sys.exit()
  

  有yield和没有yield的情况会对生成器了解多点：

  第一种：使用 yield

  #!/usr/bin/python3
  
  import sys
  
  def fibonacci(n,w=0): # 生成器函数 - 斐波那契
      a, b, counter = 0, 1, 0
      while True:
          if (counter > n): 
              return
          yield a
          a, b = b, a + b
          print('%d,%d' % (a,b))
          counter += 1
  f = fibonacci(10,0) # f 是一个迭代器，由生成器返回生成
  
  while True:
      try:
          print (next(f), end=" ")
      except :
          sys.exit()
  

  输出结果：

  0 1,1
  1 1,2
  1 2,3
  2 3,5
  3 5,8
  5 8,13
  8 13,21
  13 21,34
  21 34,55
  34 55,89
  55 89,144
  

  第二种：不使用 yield

  #!/usr/bin/python3
  
  import sys
  
  def fibonacci(n,w=0): # 生成器函数 - 斐波那契
      a, b, counter = 0, 1, 0
      while True:
          if (counter > n): 
              return
          #yield a
          a, b = b, a + b
          print('%d,%d' % (a,b))
          counter += 1
  f = fibonacci(10,0) # f 是一个迭代器，由生成器返回生成
  
  while True:
      try:
          print (next(f), end=" ")
      except :
          sys.exit()
  

  输出结果：

  1,1
  1,2
  2,3
  3,5
  5,8
  8,13
  13,21
  21,34
  34,55
  55,89
  89,144
  

  第二种没有yield时，函数只是简单执行，没有返回迭代器f。这里的迭代器可以用生成l列表来理解一下：

  >>> l = [i for i in range(0,15)]
  >>> print(l)
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
  >>> m = (i for i in range(0,15))
  >>> print(m)
   at 0x104b6f258>
  >>> for g in m:
  ...     print(g,end=', ')
  ... 
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
  

  什么情况下需要使用 yield？

  一个函数 f，f 返回一个 list，这个 list 是动态计算出来的（不管是数学上的计算还是逻辑上的读取格式化），并且这个 list 会很大（无论是固定很大还是随着输入参数的增大而增大），这个时候，我们希望每次调用这个函数并使用迭代器进行循环的时候一个一个的得到每个 list 元素而不是直接得到一个完整的 list 来节省内存，这个时候 yield 就很有用。

  具体怎么使用 yield 参考：Python yield 使用浅析

  以斐波那契函数为例，我们一般希望从 n 返回一个 n 个数的 list：

  def fab(max): 
     n, a, b = 0, 0, 1 
     L = [] 
     while n < max: 
         L.append(b) 
         a, b = b, a + b 
         n = n + 1 
     return L
  

  上面那个 fab 函数从参数 max 返回一个有 max 个元素的 list，当这个 max 很大的时候，会非常的占用内存。

  一般我们使用的时候都是这个样子的，比如：

  f = iter(fab(1000))
  while True:
      try:
          print (next(f), end=" ")
      except StopIteration:
          sys.exit()
  

  这样我们实际上是先生成了一个 1000 个元素的 list:f，然后我们再去使用这个 f。

  现在，我们换一个方法：

  因为我们实际使用的是 list 的遍历，也就是 list 的迭代器。那么我们可以让这个函数 fab 每次只返回一个迭代器——一个计算结果，而不是一个完整的 list：

  def fab(max): 
      n, a, b = 0, 0, 1 
      while n < max: 
          yield b 
          # print b 
          a, b = b, a + b 
          n = n + 1 
  

  这样，我们每次调用fab函数，比如这样：

  for x in fab(1000):
      print(x)
  

  或者 next 函数之类的，实际上的运行方式是每次的调用都在 yield 处中断并返回一个结果，然后再次调用的时候再恢复中断继续运行。

def get():
    m = 0
    n = 2
    l = ['s',1,3]
    k = {1:1,2:2}
    p = ('2','s','t')
    while True:
        m += 1
        yield m
        yield m ,n ,l ,k ,p
        
it = get()
print(next(it)) #1
print(next(it)) #(1, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't'))

print(next(it)) #2
print(type(next(it))) #

如果再加一句:

print(type(next(it))) #  #返回的是整形

所以返回值的类型，应该是当前调用时，yield 返回值的类型。

字符串，列表或元组对象都可用于创建迭代器。

字符串（Strings）：

普通的旧字符串也是可迭代的。

for s in "hello":
    print s

输出结果为：

h
e
l
l
o

列表（Lists）：

这些可能是最明显的迭代。

for x in [None,3,4.5,"foo",lambda : "moo",object,object()]:
    print "{0}  ({1})".format(x,type(x))

输出结果为：

None  ()
3  ()
4.5  ()
foo  ()
 at 0x7feec7fa7578>  ()
  ()